home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / superopt.5 / superopt / superopt-2.5 / synth.def < prev    next >
Encoding:
Text File  |  1995-05-24  |  166.0 KB  |  4,095 lines
  1.  
  2. /* Recursively investigate all possible instruction sequences for the
  3.    current target.
  4.  
  5.    SEQUENCE contains the instructions defined so far.
  6.  
  7.    N_INSNS is the number of instructions, including the one we will
  8.    generate this time, in SEQUENCE.
  9.  
  10.    VALUES contains the values in register 0..N_VALUES.
  11.  
  12.    N_VALUES is the number of registers that have been assigned values by
  13.    the insns so far.
  14.  
  15.    GOAL_VALUE is the value we aim at, when the sequence is ready.
  16.  
  17.    ALLOWED_COST is the maximum allowed cost of the remaining sequence.
  18.  
  19.    CY_IN is the carry flag.  It is negative if no instruction has yet
  20.    defined it (this to pruning the search tree), and otherwise takes the
  21.    values 0 or 1 according to the conventions of the current target.
  22.  
  23.    PRUNE_HINT contains flags to assist pruning of the search tree.  */
  24.  
  25. #if SPARC || POWER || M88000 || AM29K || ALPHA
  26. void
  27. MAKENAME(synth) (insn_t *sequence,
  28.          int n_insns,
  29.          word *values,
  30.          int n_values,
  31.          word goal_value,
  32.          int allowed_cost,
  33.          int ci,
  34.          int prune_hint)
  35. {
  36.   int s1, s2;
  37.   word v, r1, r2;
  38.   int co;
  39.   int last_dest;
  40.  
  41. #ifdef TIMING
  42.   unsigned long time_start = cputime();
  43. #endif
  44.  
  45.   if (n_insns > 0)
  46.     last_dest = sequence[n_insns - 1].d;
  47.   else
  48.     last_dest = -1;
  49.  
  50.   /* Binary operations with carry-in.  */
  51.   if (ci >= 0 && flag_use_carry)
  52.     {
  53.       for (s1 = n_values - 1; s1 >= 0; s1--)
  54.     {
  55.       r1 = values[s1];
  56.       for (s2 = s1 - 1; s2 >= 0; s2--)
  57.         {
  58.           r2 = values[s2];
  59.  
  60.           if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  61.         {
  62.           /* We are in a leaf node.  CY was not set (to 0, 1 or to
  63.              a data dependent value) by the previous insn.
  64.  
  65.              So one of the input operands has to be the result
  66.              operand of the previous insn for that insn to be
  67.              meaningful.  */
  68.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  69.             continue;
  70.         }
  71.  
  72. #if SPARC || POWER || M88000 || AM29K
  73.           /* sparc:        addxcc
  74.          rs6000:    ae
  75.          m88000:    addu.cio
  76.          am29k:        addc */
  77.           PERFORM_ADD_CIO(v, co, r1, r2, ci);
  78.           RECURSE(ADD_CIO, s1, s2, CY_JUST_SET);
  79. #endif
  80. #if SPARC || M88000
  81.           /* sparc:        addx
  82.          m88000:    addu.ci */
  83.           PERFORM_ADD_CI(v, co, r1, r2, ci);
  84.           RECURSE(ADD_CI, s1, s2, prune_hint & ~CY_JUST_SET);
  85. #endif
  86. #if SPARC
  87.           /* sparc:        subxcc */
  88.           PERFORM_SUB_CIO(v, co, r1, r2, ci);
  89.           RECURSE(SUB_CIO, s1, s2, CY_JUST_SET);
  90.           PERFORM_SUB_CIO(v, co, r2, r1, ci);
  91.           RECURSE(SUB_CIO, s2, s1, CY_JUST_SET);
  92. #endif
  93. #if SPARC
  94.           /* sparc:        subx */
  95.           PERFORM_SUB_CI(v, co, r1, r2, ci);
  96.           RECURSE(SUB_CI, s1, s2, prune_hint & ~CY_JUST_SET);
  97.           PERFORM_SUB_CI(v, co, r2, r1, ci);
  98.           RECURSE(SUB_CI, s2, s1, prune_hint & ~CY_JUST_SET);
  99. #endif
  100. #if POWER || M88000 || AM29K
  101.           /* rs6000:    sfe
  102.          m88000:    subu.cio
  103.          am29k:        subc */
  104.           PERFORM_ADC_CIO(v, co, r1, r2, ci);
  105.           RECURSE(ADC_CIO, s1, s2, CY_JUST_SET);
  106.           PERFORM_ADC_CIO(v, co, r2, r1, ci);
  107.           RECURSE(ADC_CIO, s2, s1, CY_JUST_SET);
  108. #endif
  109. #if M88000
  110.           /* m88000:    subu.ci */
  111.           PERFORM_ADC_CI(v, co, r1, r2, ci);
  112.           RECURSE(ADC_CI, s1, s2, prune_hint & ~CY_JUST_SET);
  113.           PERFORM_ADC_CI(v, co, r2, r1, ci);
  114.           RECURSE(ADC_CI, s2, s1, prune_hint & ~CY_JUST_SET);
  115. #endif
  116.         }
  117.     }
  118.     }
  119.  
  120.   /* Binary operations without carry-in.  */
  121.   for (s1 = n_values - 1; s1 >= 0; s1--)
  122.     {
  123.       r1 = values[s1];
  124.       for (s2 = s1 - 1; s2 >= 0; s2--)
  125.     {
  126.       r2 = values[s2];
  127.  
  128.       if (allowed_cost <= 1)
  129.         {
  130.           /* We are in a leaf node.
  131.  
  132.          So one of the input operands has to be the result operand
  133.          of the previous insn for that insn to be meaningful.  */
  134.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  135.         continue;
  136.         }
  137.  
  138. #ifdef DM
  139.       PERFORM_UMULWIDEN_HI(v, co, r1, r2, ci);
  140.       RECURSE(UMULWIDEN_HI, s1, s2, prune_hint & ~CY_JUST_SET);
  141. #endif
  142. #if defined (DM) || defined (MM)
  143.       PERFORM_MUL(v, co, r1, r2, ci);
  144.       RECURSE(MUL, s1, s2, prune_hint & ~CY_JUST_SET);
  145. #endif
  146. #ifdef UDIV_WITH_SDIV
  147.       PERFORM_SDIV (v, co, r1, r2, ci);
  148.       RECURSE(SDIV, s1, s2, prune_hint & ~CY_JUST_SET);
  149. #endif
  150. #if SPARC || POWER || M88000 || AM29K
  151.       /* sparc:    addcc
  152.          rs6000:    a
  153.          m88000:    addu.co
  154.          am29k:    add */
  155.       PERFORM_ADD_CO(v, co, r1, r2, ci);
  156.       RECURSE(ADD_CO, s1, s2, CY_JUST_SET);
  157. #endif
  158. #if SPARC || POWER || M88000 || ALPHA
  159.       /* sparc:    add
  160.          rs6000:    cax
  161.          m88000:    addu
  162.          alpha:    addq */
  163.       PERFORM_ADD(v, co, r1, r2, ci);
  164.       RECURSE(ADD, s1, s2, prune_hint & ~CY_JUST_SET);
  165. #endif
  166. #if SPARC
  167.       /* sparc:    subcc */
  168.       PERFORM_SUB_CO(v, co, r1, r2, ci);
  169.       RECURSE(SUB_CO, s1, s2, CY_JUST_SET);
  170.       PERFORM_SUB_CO(v, co, r2, r1, ci);
  171.       RECURSE(SUB_CO, s2, s1, CY_JUST_SET);
  172. #endif
  173. #if SPARC || POWERPC || M88000 || ALPHA
  174.       /* sparc:    sub
  175.          powerpc:    subf
  176.          m88000:    subu
  177.          alpha:    subq */
  178.       PERFORM_SUB(v, co, r1, r2, ci);
  179.       RECURSE(SUB, s1, s2, prune_hint & ~CY_JUST_SET);
  180.       PERFORM_SUB(v, co, r2, r1, ci);
  181.       RECURSE(SUB, s2, s1, prune_hint & ~CY_JUST_SET);
  182. #endif
  183. #if POWER || M88000 || AM29K
  184.       /* rs6000:    sf
  185.          m88000:    subu.co
  186.          am29k:    sub */
  187.       PERFORM_ADC_CO(v, co, r1, r2, ci);
  188.       RECURSE(ADC_CO, s1, s2, CY_JUST_SET);
  189.       PERFORM_ADC_CO(v, co, r2, r1, ci);
  190.       RECURSE(ADC_CO, s2, s1, CY_JUST_SET);
  191. #endif
  192. #if SPARC || POWER || M88000 || AM29K || ALPHA
  193.       PERFORM_AND(v, co, r1, r2, ci);
  194.       RECURSE(AND, s1, s2, prune_hint & ~CY_JUST_SET);
  195.  
  196.       PERFORM_IOR(v, co, r1, r2, ci);
  197.       RECURSE(IOR, s1, s2, prune_hint & ~CY_JUST_SET);
  198.  
  199.       PERFORM_XOR(v, co, r1, r2, ci);
  200.       RECURSE(XOR, s1, s2, prune_hint & ~CY_JUST_SET);
  201.  
  202.       PERFORM_ANDC(v, co, r1, r2, ci);
  203.       RECURSE(ANDC, s1, s2, prune_hint & ~CY_JUST_SET);
  204.       PERFORM_ANDC(v, co, r2, r1, ci);
  205.       RECURSE(ANDC, s2, s1, prune_hint & ~CY_JUST_SET);
  206. #endif
  207. #if SPARC || POWER || M88000 || ALPHA
  208.       PERFORM_IORC(v, co, r1, r2, ci);
  209.       RECURSE(IORC, s1, s2, prune_hint & ~CY_JUST_SET);
  210.       PERFORM_IORC(v, co, r2, r1, ci);
  211.       RECURSE(IORC, s2, s1, prune_hint & ~CY_JUST_SET);
  212. #endif
  213. #if SPARC || POWER || M88000 || AM29K || ALPHA
  214.       PERFORM_EQV(v, co, r1, r2, ci);
  215.       RECURSE(EQV, s1, s2, prune_hint & ~CY_JUST_SET);
  216. #endif
  217. #if POWER || AM29K
  218.       PERFORM_NAND(v, co, r1, r2, ci);
  219.       RECURSE(NAND, s1, s2, prune_hint & ~CY_JUST_SET);
  220.  
  221.       PERFORM_NOR(v, co, r1, r2, ci);
  222.       RECURSE(NOR, s1, s2, prune_hint & ~CY_JUST_SET);
  223. #endif
  224. #if POWER && !defined (POWERPC)
  225.       PERFORM_DOZ(v, co, r1, r2, ci);
  226.       RECURSE(DOZ, s1, s2, prune_hint & ~CY_JUST_SET);
  227.       PERFORM_DOZ(v, co, r2, r1, ci);
  228.       RECURSE(DOZ, s2, s1, prune_hint & ~CY_JUST_SET);
  229. #endif
  230. #if AM29K
  231.       PERFORM_CPEQ(v, co, r1, r2, ci);
  232.       RECURSE(CPEQ, s1, s2, prune_hint & ~CY_JUST_SET);
  233.       PERFORM_CPGE(v, co, r1, r2, ci);
  234.       RECURSE(CPGE, s1, s2, prune_hint & ~CY_JUST_SET);
  235.       PERFORM_CPGEU(v, co, r1, r2, ci);
  236.       RECURSE(CPGEU, s1, s2, prune_hint & ~CY_JUST_SET);
  237.       PERFORM_CPGT(v, co, r1, r2, ci);
  238.       RECURSE(CPGT, s1, s2, prune_hint & ~CY_JUST_SET);
  239.       PERFORM_CPGTU(v, co, r1, r2, ci);
  240.       RECURSE(CPGTU, s1, s2, prune_hint & ~CY_JUST_SET);
  241.       PERFORM_CPLE(v, co, r1, r2, ci);
  242.       RECURSE(CPLE, s1, s2, prune_hint & ~CY_JUST_SET);
  243.       PERFORM_CPLEU(v, co, r1, r2, ci);
  244.       RECURSE(CPLEU, s1, s2, prune_hint & ~CY_JUST_SET);
  245.       PERFORM_CPLT(v, co, r1, r2, ci);
  246.       RECURSE(CPLT, s1, s2, prune_hint & ~CY_JUST_SET);
  247.       PERFORM_CPLTU(v, co, r1, r2, ci);
  248.       RECURSE(CPLTU, s1, s2, prune_hint & ~CY_JUST_SET);
  249.       PERFORM_CPNEQ(v, co, r1, r2, ci);
  250.       RECURSE(CPNEQ, s1, s2, prune_hint & ~CY_JUST_SET);
  251. #endif
  252. #if ALPHA
  253.       PERFORM_CMPEQ(v, co, r1, r2, ci);
  254.       RECURSE(CMPEQ, s1, s2, prune_hint & ~CY_JUST_SET);
  255.  
  256.       PERFORM_CMPLE(v, co, r1, r2, ci);
  257.       RECURSE(CMPLE, s1, s2, prune_hint & ~CY_JUST_SET);
  258.       PERFORM_CMPLE(v, co, r2, r1, ci);
  259.       RECURSE(CMPLE, s2, s1, prune_hint & ~CY_JUST_SET);
  260.  
  261.       PERFORM_CMPLEU(v, co, r1, r2, ci);
  262.       RECURSE(CMPLEU, s1, s2, prune_hint & ~CY_JUST_SET);
  263.       PERFORM_CMPLEU(v, co, r2, r1, ci);
  264.       RECURSE(CMPLEU, s2, s1, prune_hint & ~CY_JUST_SET);
  265.  
  266.       PERFORM_CMPLT(v, co, r1, r2, ci);
  267.       RECURSE(CMPLT, s1, s2, prune_hint & ~CY_JUST_SET);
  268.       PERFORM_CMPLT(v, co, r2, r1, ci);
  269.       RECURSE(CMPLT, s2, s1, prune_hint & ~CY_JUST_SET);
  270.  
  271.       PERFORM_CMPLTU(v, co, r1, r2, ci);
  272.       RECURSE(CMPLTU, s1, s2, prune_hint & ~CY_JUST_SET);
  273.       PERFORM_CMPLTU(v, co, r2, r1, ci);
  274.       RECURSE(CMPLTU, s2, s1, prune_hint & ~CY_JUST_SET);
  275. #endif
  276. #if M88000
  277.       PERFORM_CMPPAR (v, co, r1, r2, ci);
  278.       RECURSE(CMPPAR, s1, s2, prune_hint & ~CY_JUST_SET);
  279.       PERFORM_CMPPAR (v, co, r2, r1, ci);
  280.       RECURSE(CMPPAR, s2, s1, prune_hint & ~CY_JUST_SET);
  281. #endif
  282. #if SPARC || POWER || AM29K || ALPHA
  283.       /* ??? Does POWER really have shifts that truncate the count?  */
  284.       /* ??? Should add these to other synth variants!! */
  285.       PERFORM_SHIFTL (v, co, r1, r2, ci);
  286.       RECURSE(SHIFTL, s1, s2, prune_hint & ~CY_JUST_SET);
  287.       PERFORM_SHIFTL (v, co, r2, r1, ci);
  288.       RECURSE(SHIFTL, s2, s1, prune_hint & ~CY_JUST_SET);
  289.  
  290.       PERFORM_LSHIFTR (v, co, r1, r2, ci);
  291.       RECURSE(LSHIFTR, s1, s2, prune_hint & ~CY_JUST_SET);
  292.       PERFORM_LSHIFTR (v, co, r2, r1, ci);
  293.       RECURSE(LSHIFTR, s2, s1, prune_hint & ~CY_JUST_SET);
  294. #endif
  295. #if SPARC || AM29K || ALPHA
  296.       PERFORM_ASHIFTR (v, co, r1, r2, ci);
  297.       RECURSE(ASHIFTR, s1, s2, prune_hint & ~CY_JUST_SET);
  298.       PERFORM_ASHIFTR (v, co, r2, r1, ci);
  299.       RECURSE(ASHIFTR, s2, s1, prune_hint & ~CY_JUST_SET);
  300. #endif
  301. #if POWER
  302.       PERFORM_ASHIFTR_CON (v, co, r1, r2, ci);
  303.       RECURSE(ASHIFTR_CON, s1, s2, CY_JUST_SET);
  304.       PERFORM_ASHIFTR_CON (v, co, r2, r1, ci);
  305.       RECURSE(ASHIFTR_CON, s2, s1, CY_JUST_SET);
  306. #endif
  307.     }
  308.     }
  309.  
  310.   /* Unary operations with carry-in.  */
  311.   if (ci >= 0 && flag_use_carry)
  312.     {
  313.       for (s1 = n_values - 1; s1 >= 0; s1--)
  314.     {
  315.       r1 = values[s1];
  316.  
  317.       if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  318.         {
  319.           /* We are in a leaf node and CY was not set (to 1 or to a
  320.          data dependent value) by the previous insn.
  321.  
  322.          The input operand has to be the result operand of the
  323.          previous insn for that insn to be meaningful.  */
  324.           if (last_dest >= 0 && s1 != last_dest)
  325.         continue;
  326.         }
  327.  
  328. #if SPARC || POWER || M88000 || AM29K
  329.       /* d,cy = 2*r1 + cy
  330.          sparc:    addxcc    s1,s1,d
  331.          rs6000:    ae    d,s1,s1
  332.          m88000:    addu.cio d,s1,s1
  333.          am29k:        addc    d,s1,s1 */
  334.       PERFORM_ADD_CIO(v, co, r1, r1, ci);
  335.       RECURSE(ADD_CIO, s1, s1, CY_JUST_SET);
  336. #endif
  337. #if SPARC || M88000
  338.       /* d = 2*r1 + cy
  339.          sparc:    addx    s1,s1,d
  340.          m88000:    addu.ci    d,s1,s1  */
  341.       PERFORM_ADD_CI(v, co, r1, r1, ci);
  342.       RECURSE(ADD_CI, s1, s1, prune_hint & ~CY_JUST_SET);
  343. #endif
  344. #if SPARC || POWER || M88000 || AM29K
  345.       /* d,cy = r1 + cy - 1
  346.          sparc:    addxcc    s1,-1,d
  347.          rs6000:    ame    d,s1
  348.          m88000:    subu.cio d,s1,r0
  349.          am29k:    subc    d,s1,0 */
  350.       PERFORM_ADD_CIO(v, co, r1, VALUE(-1), ci);
  351.       RECURSE(ADD_CIO, s1, CNST(-1), CY_JUST_SET);
  352. #endif
  353. #if SPARC || POWER || M88000 || AM29K
  354.       /* d,cy = r1 + cy
  355.          sparc:    addxcc    s1,0,d
  356.          rs6000:    aze    d,s1
  357.          m88000:    addu.cio d,s1,r0
  358.          am29k:    addc    d,s1,0 */
  359.       PERFORM_ADD_CIO(v, co, r1, VALUE(0), ci);
  360.       RECURSE(ADD_CIO, s1, CNST(0), CY_JUST_SET);
  361. #endif
  362. #if SPARC
  363.       /* d,cy = 0 - r1 - cy
  364.          sparc:    subxcc    %g0,s1,d */
  365.       PERFORM_SUB_CIO(v, co, VALUE(0), r1, ci);
  366.       RECURSE(SUB_CIO, CNST(0), s1, CY_JUST_SET);
  367. #endif
  368. #if SPARC
  369.       /* d = r1 + 1 - cy
  370.          sparc:    subx    s1,-1,d */
  371.       PERFORM_SUB_CI(v, co, r1, VALUE(-1), ci);
  372.       RECURSE(SUB_CI, s1, CNST(-1), prune_hint & ~CY_JUST_SET);
  373. #endif
  374. #if SPARC
  375.       /* d,cy = r1 + 1 - cy
  376.          sparc:    subxcc    s1,-1,d */
  377.       PERFORM_SUB_CIO(v, co, r1, VALUE(-1), ci);
  378.       RECURSE(SUB_CIO, s1, CNST(-1), CY_JUST_SET);
  379. #endif
  380. #if POWER
  381.       /* d,cy = -1 + ~r1 + cy
  382.          rs6000:    sfme    d,s1 */
  383.       PERFORM_ADC_CIO(v, co, VALUE(-1), r1, ci);
  384.       RECURSE(ADC_CIO, CNST(-1), s1, CY_JUST_SET);
  385. #endif
  386. #if POWER || M88000 || AM29K
  387.       /* d,cy = ~r1 + cy
  388.          m88000:    subu.cio d,r0,s1
  389.          rs6000:    sfze    d,s1
  390.          am29k:    subrc    d,s1,0 */
  391.       PERFORM_ADC_CIO(v, co, VALUE(0), r1, ci);
  392.       RECURSE(ADC_CIO, CNST(0), s1, CY_JUST_SET);
  393. #endif
  394.     }
  395.     }
  396.  
  397.   /* Unary operations without carry-in.  */
  398.   for (s1 = n_values - 1; s1 >= 0; s1--)
  399.     {
  400.       r1 = values[s1];
  401.  
  402.       if (allowed_cost <= 1)
  403.     {
  404.       /* We are in a leaf node.
  405.  
  406.          The input operand has to be the result operand of the
  407.          previous insns for that insn to be meaningful.  */
  408.       if (last_dest >= 0 && s1 != last_dest)
  409.         continue;
  410.     }
  411.  
  412. #ifdef DM
  413.       PERFORM_INVDIV(v, co, r1, ci);
  414.       RECURSE(INVDIV, s1, 0, prune_hint & ~CY_JUST_SET);
  415.  
  416.       PERFORM_INVMOD(v, co, r1, ci);
  417.       RECURSE(INVMOD, s1, 0, prune_hint & ~CY_JUST_SET);
  418. #endif
  419. #if SPARC || POWER || M88000 || AM29K
  420.       /* d,cy = 2*r1
  421.      sparc:        addcc    s1,s1,d
  422.      rs6000:    a    d,s1,s1
  423.      m88000:    addu.co    d,s1,s1
  424.      am29k:        add    d,s1,s1 */
  425.       PERFORM_ADD_CO(v, co, r1, r1, ci);
  426.       RECURSE(ADD_CO, s1, s1, CY_JUST_SET);
  427. #endif
  428. #if SPARC || POWER || M88000 || AM29K || ALPHA
  429.       /* d = r1 & 1
  430.      sparc:        and    s1,1,d
  431.      rs6000:    rlinm    d,s1,0,31,31
  432.      m88000:    mask    d,s1,1
  433.      am29k:        and    d,s1,1
  434.      alpha:        and    s1,1,d */
  435.       PERFORM_AND(v, co, r1, VALUE(1), ci);
  436.       RECURSE(AND, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  437. #endif
  438. #if POWER || M88000
  439.       /* d = r1 & 0x80000000
  440.      rs6000:    rlinm    d,s1,0,0,0
  441.      m88000:    mask.u    d,s1,0x8000 */
  442.       PERFORM_AND(v, co, r1, VALUE_MIN_SIGNED, ci);
  443.       RECURSE(AND, s1, CNST_0x80000000, prune_hint & ~CY_JUST_SET);
  444.  
  445.       /* d = r1 & 0x7fffffff
  446.      rs6000:    rlinm    d,s1,0,1,31
  447.      m88000:    and.u    d,s1,0x7fff */
  448.       PERFORM_AND(v, co, r1, VALUE_MAX_SIGNED, ci);
  449.       RECURSE(AND, s1, CNST_0x7FFFFFFF, prune_hint & ~CY_JUST_SET);
  450. #endif
  451. #if POWER || M88000
  452.       PERFORM_XOR(v, co, r1, VALUE_MIN_SIGNED, ci);
  453.       RECURSE(XOR, s1, CNST_0x80000000, prune_hint & ~CY_JUST_SET);
  454.  
  455.       PERFORM_IOR(v, co, r1, VALUE_MIN_SIGNED, ci);
  456.       RECURSE(IOR, s1, CNST_0x80000000, prune_hint & ~CY_JUST_SET);
  457. #endif
  458. #if SPARC || POWER || M88000 || AM29K || ALPHA
  459.       /* d = r1 ^ 1
  460.      sparc:        xor    s1,1,d
  461.      rs6000:    xoril    d,s1,1
  462.      m88000:    xor    d,s1,1
  463.      am29k:        xor    d,s1,1
  464.      alpha:        xor    s1,1,d */
  465.       PERFORM_XOR(v, co, r1, VALUE(1), ci);
  466.       RECURSE(XOR, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  467. #endif
  468. #if SPARC || POWER || M88000 || AM29K || ALPHA
  469.       /* d = ~r1
  470.      sparc:        xnor    %g0,s1,d
  471.      rs6000:    nand    d,s1,s1
  472.      m88000:    xor.c    d,s1,r0
  473.      am29k:        nand    d,s1,s1
  474.      alpha:        ornot    $31,s1,d */
  475.       PERFORM_SUB(v, co, VALUE(-1), r1, ci);
  476.       RECURSE(SUB, CNST(-1), s1, prune_hint & ~CY_JUST_SET);
  477. #endif
  478. #if POWER
  479.       /* d,cy = -1 + ~r1 + 1 (i.e. one's complement and set carry.)
  480.      rs6000:    sfi    d,s1,-1 */
  481.       PERFORM_ADC_CO(v, co, VALUE(-1), r1, ci);
  482.       RECURSE(ADC_CO, CNST(-1), s1, CY_JUST_SET | CY_1);
  483. #endif
  484. #if SPARC || POWER || AM29K
  485.       /* d,cy = r1 + 1
  486.      sparc:        addcc    s1,1,d
  487.      rs6000:    ai    d,s1,1
  488.      am29k:        add    d,s1,1 */
  489.       PERFORM_ADD_CO(v, co, r1, VALUE(1), ci);
  490.       RECURSE(ADD_CO, s1, CNST(1), CY_JUST_SET);
  491. #endif
  492. #if SPARC || POWER || M88000 || ALPHA
  493.       /* d = r1 + 1
  494.      sparc:        add    s1,1,d
  495.      rs6000:    cal    d,1(s1)
  496.      m88000:    addu    d,s1,1
  497.      alpha:        addq    s1,1,d */
  498.       PERFORM_ADD(v, co, r1, VALUE(1), ci);
  499.       RECURSE(ADD, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  500. #endif
  501. #if 0 && POWER /* This has the same effect as a "xoriu". */
  502.       /* d = r1 + 0x80000000
  503.      rs6000:    cau    d,s1,0x8000 */
  504.       PERFORM_ADD(v, co, r1, VALUE_MIN_SIGNED, ci);
  505.       RECURSE(ADD, s1, CNST_0x80000000, CY_JUST_SET);
  506. #endif
  507. #if SPARC || POWER || AM29K /* not M88000 */
  508.       /* d,cy = r1 + -1
  509.      sparc:        addcc    s1,-1,d
  510.      rs6000:    ai    d,s1,-1
  511.      am29k:        sub    d,s1,1 */
  512.       PERFORM_ADD_CO(v, co, r1, VALUE(-1), ci);
  513.       RECURSE(ADD_CO, s1, CNST(-1), CY_JUST_SET);
  514. #endif
  515. #if SPARC || POWER || M88000 || ALPHA
  516.       /* d = r1 + -1
  517.      sparc:        sub    s1,1,d
  518.      rs6000:    cal    d,-1(s1)
  519.      m88000:    subu    d,s1,1
  520.      alpha:        subq    s1,1,d */
  521.       PERFORM_ADD(v, co, r1, VALUE(-1), ci);
  522.       RECURSE(ADD, s1, CNST(-1), prune_hint & ~CY_JUST_SET);
  523. #endif
  524. #if SPARC
  525.       /* d,cy = r1 - 1. [This isn't redundant, in spite we add -1 above.]
  526.      sparc:        subcc    s1,1,d */
  527.       PERFORM_SUB_CO(v, co, r1, VALUE(1), ci);
  528.       RECURSE(SUB_CO, s1, CNST(1), CY_JUST_SET);
  529. #endif
  530. #if SPARC
  531.       /* d,cy = -r1
  532.      sparc:        subcc    %g0,s1,d */
  533.       PERFORM_SUB_CO(v, co, VALUE(0), r1, ci);
  534.       RECURSE(SUB_CO, CNST(0), s1, CY_JUST_SET);
  535. #endif
  536. #if SPARC || POWER || M88000 || ALPHA
  537.       /* d = -r1
  538.      sparc:        sub    %g0,s1,d
  539.      rs6000:    neg    d,s1
  540.      m88000:    subu    d,r0,s1
  541.      alpha:        subq    $31,s1,d */
  542.       PERFORM_SUB(v, co, VALUE(0), r1, ci);
  543.       RECURSE(SUB, CNST(0), s1, prune_hint & ~CY_JUST_SET);
  544. #endif
  545. #if POWER || M88000 || AM29K
  546.       /* d,cy = -r1
  547.      rs6000:    sf    d,s1,0
  548.      m88000:    subu.co    d,r0,s1
  549.      am29k:        subr    d,s1,0 */
  550.       PERFORM_ADC_CO(v, co, VALUE(0), r1, ci);
  551.       RECURSE(ADC_CO, CNST(0), s1, CY_JUST_SET);
  552. #endif
  553. #if POWER && !defined (POWERPC)
  554.       /* d = abs(r1)
  555.      rs6000:    abs    d,s1 */
  556.       PERFORM_ABSVAL(v, co, r1, ci);
  557.       RECURSE(ABSVAL, s1, 0, prune_hint & ~CY_JUST_SET);
  558.  
  559.       /* d = -abs(r1)
  560.      rs6000:    nabs    d,s1 */
  561.       PERFORM_NABSVAL(v, co, r1, ci);
  562.       RECURSE(NABSVAL, s1, 0, prune_hint & ~CY_JUST_SET);
  563. #endif
  564. #if POWER && !defined (POWERPC)
  565.       PERFORM_DOZ(v, co, VALUE(0), r1, ci);
  566.       RECURSE(DOZ, CNST(0), s1, prune_hint & ~CY_JUST_SET);
  567.       PERFORM_DOZ(v, co, VALUE(-1), r1, ci);
  568.       RECURSE(DOZ, CNST(-1), s1, prune_hint & ~CY_JUST_SET);
  569. #endif
  570.       {
  571.     int cnt;
  572.     for (cnt = 1; cnt < BITS_PER_WORD; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 2))
  573.       {
  574. #if SPARC || POWER || M88000 || AM29K || ALPHA
  575.         PERFORM_LSHIFTR(v, co, r1, VALUE(cnt), ci);
  576.         RECURSE(LSHIFTR, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  577. #endif
  578. #if SPARC || M88000 || AM29K || ALPHA
  579.         PERFORM_ASHIFTR(v, co, r1, VALUE(cnt), ci);
  580.         RECURSE(ASHIFTR, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  581. #endif
  582. #if POWER
  583.         PERFORM_ASHIFTR_CON(v, co, r1, VALUE(cnt), ci);
  584.         RECURSE(ASHIFTR_CON, s1, CNST(cnt), CY_JUST_SET);
  585. #endif
  586. #if SPARC || POWER || M88000 || AM29K || ALPHA
  587.         PERFORM_SHIFTL(v, co, r1, VALUE(cnt), ci);
  588.         RECURSE(SHIFTL, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  589. #endif
  590. #if POWER || M88000
  591.         PERFORM_ROTATEL(v, co, r1, VALUE(cnt), ci);
  592.         RECURSE(ROTATEL, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  593. #endif
  594.       }
  595.       }
  596.  
  597. #if M88000
  598.       if (flag_extracts)
  599.     {
  600.       int cnt;
  601.       /* Loop to 30, not 31, since 31 would generate operations
  602.          identical to shifts by 31.  */
  603.       for (cnt = 1; cnt < BITS_PER_WORD - 1; cnt++)
  604.         {
  605.           PERFORM_EXTS1(v, co, r1, VALUE(cnt), ci);
  606.           RECURSE(EXTS1, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  607.           PERFORM_EXTU1(v, co, r1, VALUE(cnt), ci);
  608.           RECURSE(EXTU1, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  609.         }
  610.       /* Loop to 29, not 31, since 30 and 31 would generate operations
  611.          identical to shifts by 30 and 31.  */
  612.       for (cnt = 1; cnt < BITS_PER_WORD - 2; cnt++)
  613.         {
  614.           PERFORM_EXTS2(v, co, r1, VALUE(cnt), ci);
  615.           RECURSE(EXTS2, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  616.           PERFORM_EXTU2(v, co, r1, VALUE(cnt), ci);
  617.           RECURSE(EXTU2, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  618.         }
  619.     }
  620. #endif
  621. #if AM29K
  622.       PERFORM_CPEQ(v, co, r1, VALUE(0), ci);
  623.       RECURSE(CPEQ, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  624.       PERFORM_CPGE(v, co, r1, VALUE(0), ci);
  625.       RECURSE(CPGE, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  626.       PERFORM_CPGEU(v, co, r1, VALUE(0), ci);
  627.       RECURSE(CPGEU, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  628.       PERFORM_CPGT(v, co, r1, VALUE(0), ci);
  629.       RECURSE(CPGT, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  630.       PERFORM_CPGTU(v, co, r1, VALUE(0), ci);
  631.       RECURSE(CPGTU, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  632.       PERFORM_CPLE(v, co, r1, VALUE(0), ci);
  633.       RECURSE(CPLE, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  634.       PERFORM_CPLEU(v, co, r1, VALUE(0), ci);
  635.       RECURSE(CPLEU, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  636.       PERFORM_CPLT(v, co, r1, VALUE(0), ci);
  637.       RECURSE(CPLT, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  638.       PERFORM_CPLTU(v, co, r1, VALUE(0), ci);
  639.       RECURSE(CPLTU, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  640.       PERFORM_CPNEQ(v, co, r1, VALUE(0), ci);
  641.       RECURSE(CPNEQ, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  642. #endif
  643. #if ALPHA
  644.       PERFORM_CMPEQ(v, co, r1, VALUE(0), ci);
  645.       RECURSE(CMPEQ, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  646.  
  647.       PERFORM_CMPLE(v, co, r1, VALUE(0), ci);
  648.       RECURSE(CMPLE, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  649.       PERFORM_CMPLE(v, co, VALUE(0), r1, ci);
  650.       RECURSE(CMPLE, CNST(0), s1, prune_hint & ~CY_JUST_SET);
  651.  
  652.       PERFORM_CMPLEU(v, co, r1, VALUE(0), ci);
  653.       RECURSE(CMPLEU, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  654. /*    PERFORM_CMPLEU(v, co, VALUE(0), r1, ci);    == 1        */
  655. /*    RECURSE(CMPLEU, CNST(0), s1, prune_hint & ~CY_JUST_SET);    */
  656.  
  657. /*    PERFORM_CMPLT(v, co, r1, VALUE(0), ci);    == srl r,63,d    */
  658. /*    RECURSE(CMPLT, s1, CNST(0), prune_hint & ~CY_JUST_SET);    */
  659.       PERFORM_CMPLT(v, co, VALUE(0), r1, ci);
  660.       RECURSE(CMPLT, CNST(0), s1, prune_hint & ~CY_JUST_SET);
  661.  
  662. /*    PERFORM_CMPLTU(v, co, r1, VALUE(0), ci);    == 0        */
  663. /*    RECURSE(CMPLTU, s1, CNST(0), prune_hint & ~CY_JUST_SET);    */
  664.       PERFORM_CMPLTU(v, co, VALUE(0), r1, ci);
  665.       RECURSE(CMPLTU, CNST(0), s1, prune_hint & ~CY_JUST_SET);
  666. #endif
  667. #if POWER || AM29K
  668.       PERFORM_CLZ(v, co, r1, ci);
  669.       RECURSE(CLZ, s1, 0, prune_hint & ~CY_JUST_SET);
  670. #endif
  671. #if M88000
  672.       PERFORM_FF1(v, co, r1, ci);
  673.       RECURSE(FF1, s1, 0, prune_hint & ~CY_JUST_SET);
  674. #endif
  675. #if M88000
  676.       PERFORM_CMPPAR (v, co, r1, VALUE(0), ci);
  677.       RECURSE(CMPPAR, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  678.       PERFORM_CMPPAR (v, co, VALUE(0), r1, ci);
  679.       RECURSE(CMPPAR, CNST(0), s1, prune_hint & ~CY_JUST_SET);
  680. #endif
  681. #if ALPHA    /* Copy register->register because of cmov.  */
  682.       /* d = r1
  683.      alpha:        bis    r1,r1,d */
  684.       PERFORM_COPY(v, co, r1, ci);
  685.       RECURSE(COPY, s1, 0, prune_hint & ~CY_JUST_SET);
  686. #endif
  687.     }
  688.  
  689. #if ALPHA
  690.   /* Alpha conditional move instructions need special treatment.  We let all
  691.      other instructions assign the next higher-numbered register, but we
  692.      can't do that here since cmov insns leave the register unchanged if the
  693.      instruction condition is not satisfied.  Instead we let the cmov
  694.      instructions non-deterministically overwrite all already-defined
  695.      registers.  */
  696.   for (s1 = n_values - 1; s1 >= 0; s1--)
  697.     {
  698.       r1 = values[s1];
  699.       for (s2 = s1 - 1; s2 >= 0; s2--)
  700.     {
  701.       int dr;
  702.       r2 = values[s2];
  703.  
  704.       for (dr = n_values - 1; dr >= 0; dr--)
  705.         {
  706.           if (allowed_cost <= 1)
  707.         {
  708.           /* We are in a leaf node.  */
  709.  
  710.           /* One of the input operands has to be the result operand
  711.              of the previous insn for that insn to be meaningful.
  712.              For CMOVE, we have to consider the destination as an input
  713.              operand, since its result is not dying here.   */
  714.           if (last_dest >= 0
  715.               && s1 != last_dest && s2 != last_dest && dr != last_dest)
  716.             continue;
  717.         }
  718.  
  719.           v = values[dr];
  720.           PERFORM_CMOVEQ (v, co, r1, r2, ci);
  721.           CRECURSE_2OP(CMOVEQ, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  722.           v = values[dr];
  723.           PERFORM_CMOVEQ (v, co, r2, r1, ci);
  724.           CRECURSE_2OP(CMOVEQ, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  725.  
  726.           v = values[dr];
  727.           PERFORM_CMOVNE (v, co, r1, r2, ci);
  728.           CRECURSE_2OP(CMOVNE, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  729.           v = values[dr];
  730.           PERFORM_CMOVNE (v, co, r2, r1, ci);
  731.           CRECURSE_2OP(CMOVNE, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  732.  
  733.           v = values[dr];
  734.           PERFORM_CMOVLT (v, co, r1, r2, ci);
  735.           CRECURSE_2OP(CMOVLT, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  736.           v = values[dr];
  737.           PERFORM_CMOVLT (v, co, r2, r1, ci);
  738.           CRECURSE_2OP(CMOVLT, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  739.  
  740.           v = values[dr];
  741.           PERFORM_CMOVGE (v, co, r1, r2, ci);
  742.           CRECURSE_2OP(CMOVGE, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  743.           v = values[dr];
  744.           PERFORM_CMOVGE (v, co, r2, r1, ci);
  745.           CRECURSE_2OP(CMOVGE, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  746.  
  747.           v = values[dr];
  748.           PERFORM_CMOVLE (v, co, r1, r2, ci);
  749.           CRECURSE_2OP(CMOVLE, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  750.           v = values[dr];
  751.           PERFORM_CMOVLE (v, co, r2, r1, ci);
  752.           CRECURSE_2OP(CMOVLE, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  753.  
  754.           v = values[dr];
  755.           PERFORM_CMOVGT (v, co, r1, r2, ci);
  756.           CRECURSE_2OP(CMOVGT, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  757.           v = values[dr];
  758.           PERFORM_CMOVGT (v, co, r2, r1, ci);
  759.           CRECURSE_2OP(CMOVGT, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  760.         }
  761.     }
  762.     }
  763.  
  764.   for (s1 = n_values - 1; s1 >= 0; s1--)
  765.     {
  766.       int dr;
  767.       r1 = values[s1];
  768.  
  769.       for (dr = n_values - 1; dr >= 0; dr--)
  770.     {
  771.       if (allowed_cost <= 1)
  772.         {
  773.           /* We are in a leaf node.
  774.  
  775.          The input operand has to be the result operand of the
  776.          previous insns for that insn to be meaningful.
  777.          For CMOVE, we have to consider the destination as an input
  778.          operand, since its result is not dying here.   */
  779.           if (last_dest >= 0 && s1 != last_dest && dr != last_dest)
  780.         continue;
  781.         }
  782.  
  783.       v = values[dr];
  784.       PERFORM_CMOVEQ (v, co, r1, VALUE(0), ci);
  785.       CRECURSE_2OP(CMOVEQ, dr, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  786.       v = values[dr];
  787.       PERFORM_CMOVNE (v, co, r1, VALUE(0), ci);
  788.       CRECURSE_2OP(CMOVNE, dr, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  789.       v = values[dr];
  790.       PERFORM_CMOVLT (v, co, r1, VALUE(0), ci);
  791.       CRECURSE_2OP(CMOVLT, dr, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  792.       v = values[dr];
  793.       PERFORM_CMOVGE (v, co, r1, VALUE(0), ci);
  794.       CRECURSE_2OP(CMOVGE, dr, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  795.       v = values[dr];
  796.       PERFORM_CMOVLE (v, co, r1, VALUE(0), ci);
  797.       CRECURSE_2OP(CMOVLE, dr, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  798.       v = values[dr];
  799.       PERFORM_CMOVGT (v, co, r1, VALUE(0), ci);
  800.       CRECURSE_2OP(CMOVGT, dr, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  801.  
  802.       v = values[dr];
  803.       PERFORM_CMOVEQ (v, co, r1, VALUE(1), ci);
  804.       CRECURSE_2OP(CMOVEQ, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  805.       v = values[dr];
  806.       PERFORM_CMOVNE (v, co, r1, VALUE(1), ci);
  807.       CRECURSE_2OP(CMOVNE, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  808.       v = values[dr];
  809.       PERFORM_CMOVLT (v, co, r1, VALUE(1), ci);
  810.       CRECURSE_2OP(CMOVLT, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  811.       v = values[dr];
  812.       PERFORM_CMOVGE (v, co, r1, VALUE(1), ci);
  813.       CRECURSE_2OP(CMOVGE, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  814.       v = values[dr];
  815.       PERFORM_CMOVLE (v, co, r1, VALUE(1), ci);
  816.       CRECURSE_2OP(CMOVLE, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  817.       v = values[dr];
  818.       PERFORM_CMOVGT (v, co, r1, VALUE(1), ci);
  819.       CRECURSE_2OP(CMOVGT, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  820.     }
  821.     }
  822. #endif /* ALPHA */
  823.  
  824.   /* 0-ary instructions, just dependent on carry.  */
  825.   if (ci >= 0 && flag_use_carry
  826.       && (allowed_cost <= 1 ? ((prune_hint & CY_JUST_SET) != 0) : 1))
  827.     {
  828.       /* We don't do "0 - 1 - cy" or "0 + 1 + cy" here.  It would
  829.      probably give very few new sequences. */
  830. #if SPARC || M88000
  831.       /* d = cy.
  832.      sparc:        addx    %g0,0,d
  833.      m88000:    addu.ci d,r0,r0 */
  834.       PERFORM_ADD_CI(v, co, VALUE(0), VALUE(0), ci);
  835.       RECURSE(ADD_CI, CNST(0), CNST(0), prune_hint & ~CY_JUST_SET);
  836. #endif
  837. #if SPARC || M88000
  838.       /* d = cy, cy = 0.
  839.      sparc:        addxcc    %g0,0,d
  840.      m88000:    addu.cio d,r0,r0 */
  841.       PERFORM_ADD_CIO(v, co, VALUE(0), VALUE(0), ci);
  842.       RECURSE(ADD_CIO, CNST(0), CNST(0), CY_JUST_SET | CY_0);
  843. #endif
  844. #if SPARC
  845.       /* Using SUB_CIO instead would make no difference.
  846.      It'd just set carry to it's old value.  */
  847.       /* d = -cy.
  848.      sparc:        subx    %g0,0,d */
  849.       PERFORM_SUB_CI(v, co, VALUE(0), VALUE(0), ci);
  850.       RECURSE(SUB_CI, CNST(0), CNST(0), prune_hint & ~CY_JUST_SET);
  851. #endif
  852. #if SPARC
  853.       /* d = 1 - cy.
  854.      sparc:        subx    %g0,-1,d */
  855.       PERFORM_SUB_CI(v, co, VALUE(0), VALUE(-1), ci);
  856.       RECURSE(SUB_CI, CNST(0), CNST(-1), CY_JUST_SET | CY_1);
  857. #endif
  858. #if SPARC
  859.       /* d = 1 - cy, cy = 1.
  860.      sparc:        subxcc    %g0,-1,d */
  861.       PERFORM_SUB_CIO(v, co, VALUE(0), VALUE(-1), ci);
  862.       RECURSE(SUB_CIO, CNST(0), CNST(-1), CY_JUST_SET | CY_1);
  863. #endif
  864. #if SPARC
  865.       /* Using ADD_CIO instead would make no difference.
  866.      It'd just set carry to it's old value.  */
  867.       /* d = -1 + cy.
  868.      sparc:        addx    %g0,-1,d */
  869.       PERFORM_ADD_CI(v, co, VALUE(0), VALUE(-1), ci);
  870.       RECURSE(ADD_CI, CNST(0), CNST(-1), prune_hint & ~CY_JUST_SET);
  871. #endif
  872. #if POWER || AM29K /* Use subu.ci on 88k instead with same result */
  873.       /* d = -1 + cy, cy = cy
  874.      rs6000:    sfe    d,d,d
  875.      am29k:        subc    d,d,d */
  876.       PERFORM_ADC_CIO(v, co, VALUE(0), VALUE(0), ci);
  877.       RECURSE(ADC_CIO, n_values, n_values, prune_hint & ~CY_JUST_SET);
  878. #endif
  879. #if M88000
  880.       /* d = -1 + cy
  881.      m88000:    subu.ci    d,r0,r0 */
  882.       PERFORM_ADC_CI(v, co, VALUE(0), VALUE(0), ci);
  883.       RECURSE(ADC_CI, CNST(0), CNST(0), prune_hint & ~CY_JUST_SET);
  884. #endif
  885.     }
  886.  
  887.   /* Move instructions.
  888.      Don't do this if we are just permitted to do one more instruction.  */
  889.   if (allowed_cost > 1)
  890.     {
  891. #if SPARC || POWER || M88000 || AM29K
  892.       /* d = 0x80000000
  893.      sparc:        sethi    %hi(0x80000000),d
  894.      rs6000:    liu    d,0x8000
  895.      m88000:    or.u    d,r0,0x8000
  896.      am29k:        cpeq    d,gr1,gr1 */
  897.       PERFORM_COPY(v, co, VALUE_MIN_SIGNED, ci);
  898.       RECURSE(COPY, CNST_0x80000000, 0, prune_hint & ~CY_JUST_SET);
  899. #endif
  900. #if SPARC || POWER || M88000 || AM29K || ALPHA
  901.       /* d = -1
  902.      sparc:        mov    -1,d
  903.      rs6000:    lil    d,-1
  904.      m88000:    subu    d,r0,1
  905.      am29k:        constn    d,1
  906.      alpha:        lda    d,-1 */
  907.       PERFORM_COPY(v, co, VALUE(-1), ci);
  908.       RECURSE(COPY, CNST(-1), 0, prune_hint & ~CY_JUST_SET);
  909.       /* d = 1
  910.      sparc:        mov    1,d
  911.      rs6000:    lil    d,1
  912.      m88000:    addu    d,r0,1
  913.      am29k:        const    d,1
  914.      alpha:        lda    d,1 */
  915.       PERFORM_COPY(v, co, VALUE(1), ci);
  916.       RECURSE(COPY, CNST(1), 0, prune_hint & ~CY_JUST_SET);
  917. #endif
  918. #if POWER || AM29K || ALPHA    /* Sparc and 88k should not need this.
  919.                    Alpha can use it because of cmov.  */
  920.       /* d = 0
  921.      rs6000:    lil    d,0
  922.      am29k:        const    d,0
  923.      alpha:        lda    d,0 */
  924.       PERFORM_COPY(v, co, VALUE(0), ci);
  925.       RECURSE(COPY, CNST(0), 0, prune_hint & ~CY_JUST_SET);
  926. #endif
  927. #if M88000
  928.       /* d = 0x7fffffff
  929.      m88000:    set    d,r0,31<0> */
  930.       PERFORM_COPY(v, co, VALUE_MAX_SIGNED, ci);
  931.       RECURSE(COPY, CNST_0x7FFFFFFF, 0, prune_hint & ~CY_JUST_SET);
  932. #endif
  933.     }
  934.  
  935. #ifdef TIMING
  936.   timings[allowed_cost] += cputime() - time_start;
  937. #endif
  938. }
  939. #endif
  940.  
  941. #if HPPA
  942. /* Missing insns:
  943.    * IOR,imm,s1,d using depi
  944.    * addil,0x80000000,s2,d for complementing msb
  945.    * Several (signed) completer variants for add/sub
  946.    * All completer variants for shift/copy/???
  947.    Ideas:
  948.    * After nuv, nvz, etc, we should pass CY_1; after other
  949.      conditions we should pass CY_0.
  950.    * When CY_0 or CY_1 are set (even if not CY_JUST_SET),
  951.      we should prune some carry-inputting insns
  952.      (also for other archs).
  953.    */
  954. void
  955. MAKENAME(synth) (insn_t *sequence,
  956.          int n_insns,
  957.          word *values,
  958.          int n_values,
  959.          word goal_value,
  960.          int allowed_cost,
  961.          int ci,
  962.          int prune_hint,
  963.          int nullify_flag_in)
  964. {
  965. #ifdef TIMING
  966.   unsigned long time_start = cputime();
  967. #endif
  968.  
  969.   /* FIRSTLY EVERYTHING WITHOUT SKIP.  */
  970.   MAKENAME (synth_nonskip) (sequence, n_insns, values, n_values, goal_value,
  971.                 allowed_cost, ci, prune_hint, nullify_flag_in);
  972.  
  973. #if !MAKE_LEAF
  974.   /* SECONDLY EVERYTHING WITH CONDITIONAL SKIP.  */
  975.   /* Don't skip if end of sequence...! */
  976.   if (allowed_cost > 1)
  977.     synth_condskip (sequence, n_insns, values, n_values, goal_value,
  978.             allowed_cost, ci, prune_hint, nullify_flag_in);
  979.  
  980.   /* THIRDLY EVERYTHING WITH UNCONDITIONAL SKIP.  */
  981.   /* Don't do this if allowed_cost doesn't permit one more insn,
  982.      otherwise we would nullify a non-existing insn.
  983.      Also don't do this if the previous insn was not a nullifying
  984.      insn, because if it was not, the next instruction would never
  985.      be executed.  */
  986.   if (allowed_cost > 1 && (prune_hint & NULLIFYING_INSN))
  987.     synth_skip (sequence, n_insns, values, n_values, goal_value, allowed_cost,
  988.         ci, prune_hint, nullify_flag_in);
  989. #endif
  990.  
  991. #ifdef TIMING
  992.   timings[allowed_cost] += cputime() - time_start;
  993. #endif
  994. }
  995.  
  996. void
  997. MAKENAME(synth_nonskip) (insn_t *sequence,
  998.              int n_insns,
  999.              word *values,
  1000.              int n_values,
  1001.              word goal_value,
  1002.              int allowed_cost,
  1003.              int ci,
  1004.              int prune_hint,
  1005.              int nullify_flag_in)
  1006. {
  1007.   int s1, s2;
  1008.   word v, r1, r2;
  1009.   int co;
  1010.   int last_dest;
  1011.   int dr, dr_lim;
  1012.   int nullify_flag;
  1013.  
  1014.   if (n_insns > 0)
  1015.     last_dest = sequence[n_insns - 1].d;
  1016.   else
  1017.     last_dest = -1;
  1018.  
  1019.   /* Binary operations with carry-in.  */
  1020.   if (ci >= 0 && flag_use_carry)
  1021.     {
  1022.       for (s1 = n_values - 1; s1 >= 0; s1--)
  1023.     {
  1024.       r1 = values[s1];
  1025.       for (s2 = s1 - 1; s2 >= 0; s2--)
  1026.         {
  1027.           r2 = values[s2];
  1028.  
  1029.           if (allowed_cost <= 1 && (prune_hint & (CY_JUST_SET | NULLIFYING_INSN)) == 0)
  1030.         {
  1031.           /* We are in a leaf node.  CY was not set (to 0, 1 or to
  1032.              a data dependent value) by the previous insn, nor was
  1033.              the N (nullification) bit.
  1034.              So one of the input operands has to be the result
  1035.              operand of the previous insn for that insn to be
  1036.              meaningful.  */
  1037.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  1038.             continue;
  1039.         }
  1040.  
  1041.           dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1042.           for (dr = n_values; dr >= dr_lim; dr--)
  1043.         {
  1044.           /* hppa:        addc */
  1045.           if (!nullify_flag_in) PERFORM_ADD_CIO(v, co, r1, r2, ci);
  1046.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1047.           PA_RECURSE(ADD_CIO, dr, s1, s2, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1048.  
  1049.           /* hppa:        subb */
  1050.           if (!nullify_flag_in) PERFORM_ADC_CIO(v, co, r1, r2, ci);
  1051.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1052.           PA_RECURSE(ADC_CIO, dr, s1, s2, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1053.           if (!nullify_flag_in) PERFORM_ADC_CIO(v, co, r2, r1, ci);
  1054.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1055.           PA_RECURSE(ADC_CIO, dr, s2, s1, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1056.         }
  1057.         }
  1058.     }
  1059.     }
  1060.  
  1061.   /* Binary operations without carry-in.  */
  1062.   for (s1 = n_values - 1; s1 >= 0; s1--)
  1063.     {
  1064.       r1 = values[s1];
  1065.       for (s2 = s1 - 1; s2 >= 0; s2--)
  1066.     {
  1067.       r2 = values[s2];
  1068.  
  1069.       if (allowed_cost <= 1 && (prune_hint & NULLIFYING_INSN) == 0)
  1070.         {
  1071.           /* We are in a leaf node.  The N (nullification) bit was not
  1072.          set by the previous insn.
  1073.          So one of the input operands has to be the result operand
  1074.          of the previous insn for that insn to be meaningful.  */
  1075.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  1076.         continue;
  1077.         }
  1078.  
  1079.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1080.       for (dr = n_values; dr >= dr_lim; dr--)
  1081.         {
  1082.           /* hppa:    add */
  1083.           if (!nullify_flag_in) PERFORM_ADD_CO(v, co, r1, r2, ci);
  1084.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1085.           PA_RECURSE(ADD_CO, dr, s1, s2, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1086.  
  1087.           /* hppa:    addl */
  1088.           if (!nullify_flag_in) PERFORM_ADD(v, co, r1, r2, ci);
  1089.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1090.           PA_RECURSE(ADD, dr, s1, s2, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1091.  
  1092.           /* hppa:    uaddcm */
  1093.           if (!nullify_flag_in) PERFORM_ADDCMPL(v, co, r1, r2, ci);
  1094.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1095.           PA_RECURSE(ADDCMPL, dr, s1, s2, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1096.           if (!nullify_flag_in) PERFORM_ADDCMPL(v, co, r2, r1, ci);
  1097.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1098.           PA_RECURSE(ADDCMPL, dr, s2, s1, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1099.  
  1100.           /* hppa:    sub */
  1101.           if (!nullify_flag_in) PERFORM_ADC_CO(v, co, r1, r2, ci);
  1102.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1103.           PA_RECURSE(ADC_CO, dr, s1, s2, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1104.           if (!nullify_flag_in) PERFORM_ADC_CO(v, co, r2, r1, ci);
  1105.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1106.           PA_RECURSE(ADC_CO, dr, s2, s1, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1107.  
  1108.           /* hppa:    and */
  1109.           if (!nullify_flag_in) PERFORM_AND(v, co, r1, r2, ci);
  1110.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1111.           PA_RECURSE(AND, dr, s1, s2, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1112.  
  1113.           /* hppa:    or */
  1114.           if (!nullify_flag_in) PERFORM_IOR(v, co, r1, r2, ci);
  1115.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1116.           PA_RECURSE(IOR, dr, s1, s2, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1117.  
  1118.           /* hppa:    xor */
  1119.           if (!nullify_flag_in) PERFORM_XOR(v, co, r1, r2, ci);
  1120.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1121.           PA_RECURSE(XOR, dr, s1, s2, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1122.  
  1123.           /* hppa:    andcm */
  1124.           if (!nullify_flag_in) PERFORM_ANDC(v, co, r1, r2, ci);
  1125.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1126.           PA_RECURSE(ANDC, dr, s1, s2, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1127.           if (!nullify_flag_in) PERFORM_ANDC(v, co, r2, r1, ci);
  1128.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1129.           PA_RECURSE(ANDC, dr, s2, s1, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1130.         }
  1131.     }
  1132.     }
  1133.  
  1134.   /* Unary operations with carry-in.  */
  1135.   if (ci >= 0 && flag_use_carry)
  1136.     {
  1137.       for (s1 = n_values - 1; s1 >= 0; s1--)
  1138.     {
  1139.       r1 = values[s1];
  1140.  
  1141.       if (allowed_cost <= 1 && (prune_hint & (CY_JUST_SET | NULLIFYING_INSN)) == 0)
  1142.         {
  1143.           /* We are in a leaf node.  CY was not set (to 0, 1 or to
  1144.          a data dependent value) by the previous insn, nor was
  1145.          the N (nullification) bit.
  1146.          The input operand has to be the result operand of the
  1147.          previous insn for that insn to be meaningful.  */
  1148.           if (last_dest >= 0 && s1 != last_dest)
  1149.         continue;
  1150.         }
  1151.  
  1152.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1153.       for (dr = n_values; dr >= dr_lim; dr--)
  1154.         {
  1155.           /* d,cy = 2*r1 + cy
  1156.          hppa:    addc    s1,s1,d */
  1157.           if (!nullify_flag_in) PERFORM_ADD_CIO(v, co, r1, r1, ci);
  1158.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1159.           PA_RECURSE(ADD_CIO, dr, s1, s1, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1160.  
  1161.           /* d,cy = r1 + cy - 1
  1162.          hppa:    subb    s1,r0,d */
  1163.           if (!nullify_flag_in) PERFORM_ADD_CIO(v, co, r1, VALUE(-1), ci);
  1164.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1165.           PA_RECURSE(ADD_CIO, dr, s1, CNST(-1), CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1166.  
  1167.           /* d,cy = r1 + cy
  1168.          hppa:    addc    s1,r0,d */
  1169.           if (!nullify_flag_in) PERFORM_ADD_CIO(v, co, r1, VALUE(0), ci);
  1170.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1171.           PA_RECURSE(ADD_CIO, dr, s1, CNST(0), CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1172.  
  1173.           /* d,cy = ~r1 + cy
  1174.          hppa:    subb    r0,s1,d */
  1175.           if (!nullify_flag_in) PERFORM_ADC_CIO(v, co, VALUE(0), r1, ci);
  1176.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1177.           PA_RECURSE(ADC_CIO, dr, CNST(0), s1, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1178.         }
  1179.     }
  1180.     }
  1181.  
  1182.   /* Unary operations without carry-in.  */
  1183.   for (s1 = n_values - 1; s1 >= 0; s1--)
  1184.     {
  1185.       r1 = values[s1];
  1186.  
  1187.       if (allowed_cost <= 1 && (prune_hint & NULLIFYING_INSN) == 0)
  1188.     {
  1189.       /* We are in a leaf node.  The N (nullification) bit was not
  1190.          set by the previous insn.
  1191.          The input operand has to be the result operand of the
  1192.          previous insns for that insn to be meaningful.  */
  1193.       if (last_dest >= 0 && s1 != last_dest)
  1194.         continue;
  1195.     }
  1196.  
  1197.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1198.       for (dr = n_values; dr >= dr_lim; dr--)
  1199.     {
  1200.       /* d,cy = 2*r1
  1201.          hppa:        add    s1,s1,d */
  1202.       if (!nullify_flag_in) PERFORM_ADD_CO(v, co, r1, r1, ci);
  1203.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1204.       PA_RECURSE(ADD_CO, dr, s1, s1, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1205.       /* d = r1 & 1
  1206.          hppa:        extru    s1,31,1,d */
  1207.       if (!nullify_flag_in) PERFORM_AND(v, co, r1, VALUE(1), ci);
  1208.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1209.       PA_RECURSE(AND, dr, s1, CNST(1), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1210.       /* d = r1 & 0x7fffffff
  1211.          hppa:        extru    s1,31,31,d */
  1212.       if (!nullify_flag_in) PERFORM_AND(v, co, r1, VALUE_MAX_SIGNED, ci);
  1213.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1214.       PA_RECURSE(AND, dr, s1, CNST_0x7FFFFFFF, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1215.       /* d = ~r1
  1216.          hppa:        andcm    r0,s1,d */
  1217.       if (!nullify_flag_in) PERFORM_SUB(v, co, VALUE(-1), r1, ci);
  1218.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1219.       PA_RECURSE(SUB, dr, CNST(-1), s1, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1220.       /* d,cy = -1 + ~r1 + 1 (i.e. one's complement and set carry.)
  1221.          hppa:    subi    -1,s1,d */
  1222.       if (!nullify_flag_in) PERFORM_ADC_CO(v, co, VALUE(-1), r1, ci);
  1223.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1224.       PA_RECURSE(ADC_CO, dr, CNST(-1), s1, (CY_JUST_SET | CY_1) & ~NULLIFYING_INSN, NOT_NULLIFY);
  1225.       /* d,cy = r1 + 1
  1226.          hppa:        addi    1,s1,d */
  1227.       if (!nullify_flag_in) PERFORM_ADD_CO(v, co, r1, VALUE(1), ci);
  1228.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1229.       PA_RECURSE(ADD_CO, dr, s1, CNST(1), CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1230.       /* d = r1 + 1
  1231.          hppa:        ldo    1(s1),d */
  1232.       if (!nullify_flag_in) PERFORM_ADD(v, co, r1, VALUE(1), ci);
  1233.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1234.       PA_RECURSE(ADD, dr, s1, CNST(1), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1235.       /* d,cy = r1 + -1
  1236.          hppa:        addi    -1,s1,d */
  1237.       if (!nullify_flag_in) PERFORM_ADD_CO(v, co, r1, VALUE(-1), ci);
  1238.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1239.       PA_RECURSE(ADD_CO, dr, s1, CNST(-1), CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1240.       /* d = r1 - 1
  1241.          hppa:        ldo    -1(s1),d */
  1242.       if (!nullify_flag_in) PERFORM_ADD(v, co, r1, VALUE(-1), ci);
  1243.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1244.       PA_RECURSE(ADD, dr, s1, CNST(-1), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1245.       /* d,cy = -r1
  1246.          hppa:        subi    0,s1,d */
  1247.       if (!nullify_flag_in) PERFORM_ADC_CO(v, co, VALUE(0), r1, ci);
  1248.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1249.       PA_RECURSE(ADC_CO, dr, CNST(0), s1, CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1250.  
  1251.       {
  1252.         int cnt;
  1253.         for (cnt = 1; cnt < BITS_PER_WORD; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 2))
  1254.           {
  1255.         if (!nullify_flag_in) PERFORM_LSHIFTR(v, co, r1, VALUE(cnt), ci);
  1256.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1257.         PA_RECURSE(LSHIFTR, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1258.  
  1259.         if (!nullify_flag_in) PERFORM_ASHIFTR(v, co, r1, VALUE(cnt), ci);
  1260.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1261.         PA_RECURSE(ASHIFTR, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1262.  
  1263.         if (!nullify_flag_in) PERFORM_SHIFTL(v, co, r1, VALUE(cnt), ci);
  1264.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1265.         PA_RECURSE(SHIFTL, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1266.  
  1267.         if (!nullify_flag_in) PERFORM_ROTATEL(v, co, r1, VALUE(cnt), ci);
  1268.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1269.         PA_RECURSE(ROTATEL, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1270.           }
  1271.       }
  1272.  
  1273.       if (flag_extracts)
  1274.         {
  1275.           int cnt;
  1276.           /* Loop to 30, not 31, since 31 would generate operations
  1277.          identical to shifts by 31.  */
  1278.           for (cnt = 1; cnt < BITS_PER_WORD - 1; cnt++)
  1279.         {
  1280.           if (!nullify_flag_in) PERFORM_EXTS1(v, co, r1, VALUE(cnt), ci);
  1281.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1282.           PA_RECURSE(EXTS1, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1283.           if (!nullify_flag_in) PERFORM_EXTU1(v, co, r1, VALUE(cnt), ci);
  1284.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1285.           PA_RECURSE(EXTU1, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1286.         }
  1287.           /* Loop to 29, not 31, since 30 and 31 would generate operations
  1288.          identical to shifts by 30 and 31.  */
  1289.           for (cnt = 1; cnt < BITS_PER_WORD - 2; cnt++)
  1290.         {
  1291.           if (!nullify_flag_in) PERFORM_EXTS2(v, co, r1, VALUE(cnt), ci);
  1292.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1293.           PA_RECURSE(EXTS2, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1294.           if (!nullify_flag_in) PERFORM_EXTU2(v, co, r1, VALUE(cnt), ci);
  1295.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1296.           PA_RECURSE(EXTU2, dr, s1, CNST(cnt), prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1297.         }
  1298.         }
  1299.     }
  1300.     }
  1301.  
  1302.   /* 0-ary instructions, just dependent on carry.  */
  1303.   if (ci >= 0 && flag_use_carry
  1304.       && (allowed_cost <= 1 ? ((prune_hint & (CY_JUST_SET | NULLIFYING_INSN)) != 0) : 1))
  1305.     {
  1306.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1307.       for (dr = n_values; dr >= dr_lim; dr--)
  1308.     {
  1309.       /* We don't do "0 - 1 - cy" or "0 + 1 + cy" here.  It would
  1310.          probably give very few new sequences. */
  1311.       /* d = cy, cy = 0.
  1312.          hppa:        addc    r0,r0,d */
  1313.       if (!nullify_flag_in) PERFORM_ADD_CIO(v, co, VALUE(0), VALUE(0), ci);
  1314.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1315.       PA_RECURSE(ADD_CIO, dr, CNST(0), CNST(0), (CY_JUST_SET | CY_0) & ~NULLIFYING_INSN, NOT_NULLIFY);
  1316.       /* d = -1 + cy, cy = cy
  1317.          hppa:        subb    d,d,d */
  1318.       if (!nullify_flag_in) PERFORM_ADC_CIO(v, co, VALUE(0), VALUE(0), ci);
  1319.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1320.       PA_RECURSE(ADC_CIO, dr, n_values, n_values, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1321.     }
  1322.     }
  1323.  
  1324.   /* Move instructions.
  1325.      Don't do this if we are just permitted to do one more instruction,
  1326.      unless we might be nullified.  */
  1327.   if (allowed_cost > 1 || (prune_hint & NULLIFYING_INSN))
  1328.     {
  1329.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1330.       for (dr = n_values; dr >= dr_lim; dr--)
  1331.     {
  1332.       /* d = 0x80000000
  1333.          hppa:        ldil    l'0x80000000,d */
  1334.       if (!nullify_flag_in) PERFORM_COPY(v, co, VALUE_MIN_SIGNED, ci);
  1335.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1336.       PA_RECURSE(COPY, dr, CNST_0x80000000, 0, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1337.       /* d = -1
  1338.          hppa:        ldi    -1,d */
  1339.       if (!nullify_flag_in) PERFORM_COPY(v, co, VALUE(-1), ci);
  1340.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1341.       PA_RECURSE(COPY, dr, CNST(-1), 0, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1342.       /* d = 1
  1343.          hppa:        ldi    1,d */
  1344.       if (!nullify_flag_in) PERFORM_COPY(v, co, VALUE(1), ci);
  1345.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1346.       PA_RECURSE(COPY, dr, CNST(1), 0, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1347.       /* d = 0
  1348.          hppa:        ldi    0,d */
  1349.       if (!nullify_flag_in) PERFORM_COPY(v, co, VALUE(0), ci);
  1350.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1351.       PA_RECURSE(COPY, dr, CNST(0), 0, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1352.       /* d = 0x7fffffff
  1353.          hppa:        zdepi    -1,31,31,d */
  1354.       if (!nullify_flag_in) PERFORM_COPY(v, co, VALUE_MAX_SIGNED, ci);
  1355.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1356.       PA_RECURSE(COPY, dr, CNST_0x7FFFFFFF, 0, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1357.     }
  1358.     }
  1359.   /* Copy register->register if we might be nullified.  */
  1360.   if (prune_hint & NULLIFYING_INSN)
  1361.     {
  1362.       for (s1 = n_values - 1; s1 >= 0; s1--)
  1363.     {
  1364.       r1 = values[s1];
  1365.       for (dr = n_values - 1; dr >= 0; dr--)
  1366.         {
  1367.           if (!nullify_flag_in) PERFORM_COPY(v, co, r1, ci);
  1368.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1369.           PA_RECURSE(COPY, dr, s1, 0, prune_hint & ~CY_JUST_SET & ~NULLIFYING_INSN, NOT_NULLIFY);
  1370.         }
  1371.     }
  1372.     }
  1373. }
  1374.  
  1375. #if !MAKE_LEAF
  1376. void
  1377. synth_condskip (insn_t *sequence,
  1378.         int n_insns,
  1379.         word *values,
  1380.         int n_values,
  1381.         word goal_value,
  1382.         int allowed_cost,
  1383.         int ci,
  1384.         int prune_hint,
  1385.         int nullify_flag_in)
  1386. {
  1387.   int s1, s2;
  1388.   word v, r1, r2;
  1389.   int co;
  1390.   int last_dest;
  1391.   int dr, dr_lim;
  1392.   int nullify_flag;
  1393.  
  1394.   if (n_insns > 0)
  1395.     last_dest = sequence[n_insns - 1].d;
  1396.   else
  1397.     last_dest = -1;
  1398.  
  1399.   /* Binary operations with carry-in.  */
  1400.   if (ci >= 0 && flag_use_carry)
  1401.     {
  1402.       for (s1 = n_values - 1; s1 >= 0; s1--)
  1403.     {
  1404.       r1 = values[s1];
  1405.       for (s2 = s1 - 1; s2 >= 0; s2--)
  1406.         {
  1407.           r2 = values[s2];
  1408.           dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1409.           for (dr = n_values; dr >= dr_lim; dr--)
  1410.         {
  1411.           /* hppa:        addc */
  1412.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEQ(v, co, nullify_flag, r1, r2, ci);
  1413.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1414.           PA_RECURSE(ADD_CIO_SEQ, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1415.           if (!nullify_flag_in) PERFORM_ADD_CIO_SNE(v, co, nullify_flag, r1, r2, ci);
  1416.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1417.           PA_RECURSE(ADD_CIO_SNE, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1418.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLTU(v, co, nullify_flag, r1, r2, ci);
  1419.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1420.           PA_RECURSE(ADD_CIO_SLTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1421.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGEU(v, co, nullify_flag, r1, r2, ci);
  1422.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1423.           PA_RECURSE(ADD_CIO_SGEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1424.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLEU(v, co, nullify_flag, r1, r2, ci);
  1425.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1426.           PA_RECURSE(ADD_CIO_SLEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1427.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGTU(v, co, nullify_flag, r1, r2, ci);
  1428.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1429.           PA_RECURSE(ADD_CIO_SGTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1430.           if (!nullify_flag_in) PERFORM_ADD_CIO_SODD(v, co, nullify_flag, r1, r2, ci);
  1431.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1432.           PA_RECURSE(ADD_CIO_SODD, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1433.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEVN(v, co, nullify_flag, r1, r2, ci);
  1434.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1435.           PA_RECURSE(ADD_CIO_SEVN, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1436.  
  1437.           /* hppa:        subb */
  1438.           if (!nullify_flag_in) PERFORM_ADC_CIO_SEQ(v, co, nullify_flag, r1, r2, ci);
  1439.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1440.           PA_RECURSE(ADC_CIO_SEQ, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1441.           if (!nullify_flag_in) PERFORM_ADC_CIO_SNE(v, co, nullify_flag, r1, r2, ci);
  1442.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1443.           PA_RECURSE(ADC_CIO_SNE, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1444.           if (!nullify_flag_in) PERFORM_ADC_CIO_SLTU(v, co, nullify_flag, r1, r2, ci);
  1445.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1446.           PA_RECURSE(ADC_CIO_SLTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1447.           if (!nullify_flag_in) PERFORM_ADC_CIO_SGEU(v, co, nullify_flag, r1, r2, ci);
  1448.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1449.           PA_RECURSE(ADC_CIO_SGEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1450.           if (!nullify_flag_in) PERFORM_ADC_CIO_SLEU(v, co, nullify_flag, r1, r2, ci);
  1451.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1452.           PA_RECURSE(ADC_CIO_SLEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1453.           if (!nullify_flag_in) PERFORM_ADC_CIO_SGTU(v, co, nullify_flag, r1, r2, ci);
  1454.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1455.           PA_RECURSE(ADC_CIO_SGTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1456.           if (!nullify_flag_in) PERFORM_ADC_CIO_SODD(v, co, nullify_flag, r1, r2, ci);
  1457.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1458.           PA_RECURSE(ADC_CIO_SODD, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1459.           if (!nullify_flag_in) PERFORM_ADC_CIO_SEVN(v, co, nullify_flag, r1, r2, ci);
  1460.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1461.           PA_RECURSE(ADC_CIO_SEVN, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1462.  
  1463.           if (!nullify_flag_in) PERFORM_ADC_CIO_SEQ(v, co, nullify_flag, r2, r1, ci);
  1464.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1465.           PA_RECURSE(ADC_CIO_SEQ, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1466.           if (!nullify_flag_in) PERFORM_ADC_CIO_SNE(v, co, nullify_flag, r2, r1, ci);
  1467.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1468.           PA_RECURSE(ADC_CIO_SNE, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1469.           if (!nullify_flag_in) PERFORM_ADC_CIO_SLTU(v, co, nullify_flag, r2, r1, ci);
  1470.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1471.           PA_RECURSE(ADC_CIO_SLTU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1472.           if (!nullify_flag_in) PERFORM_ADC_CIO_SGEU(v, co, nullify_flag, r2, r1, ci);
  1473.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1474.           PA_RECURSE(ADC_CIO_SGEU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1475.           if (!nullify_flag_in) PERFORM_ADC_CIO_SLEU(v, co, nullify_flag, r2, r1, ci);
  1476.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1477.           PA_RECURSE(ADC_CIO_SLEU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1478.           if (!nullify_flag_in) PERFORM_ADC_CIO_SGTU(v, co, nullify_flag, r2, r1, ci);
  1479.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1480.           PA_RECURSE(ADC_CIO_SGTU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1481.           if (!nullify_flag_in) PERFORM_ADC_CIO_SODD(v, co, nullify_flag, r2, r1, ci);
  1482.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1483.           PA_RECURSE(ADC_CIO_SODD, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1484.           if (!nullify_flag_in) PERFORM_ADC_CIO_SEVN(v, co, nullify_flag, r2, r1, ci);
  1485.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1486.           PA_RECURSE(ADC_CIO_SEVN, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1487.         }
  1488.         }
  1489.     }
  1490.     }
  1491.  
  1492.   /* Binary operations without carry-in.  */
  1493.   for (s1 = n_values - 1; s1 >= 0; s1--)
  1494.     {
  1495.       r1 = values[s1];
  1496.       for (s2 = s1 - 1; s2 >= 0; s2--)
  1497.     {
  1498.       r2 = values[s2];
  1499.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1500.       for (dr = n_values; dr >= dr_lim; dr--)
  1501.         {
  1502.           /* hppa:    add */
  1503.           if (!nullify_flag_in) PERFORM_ADD_CO_SEQ(v, co, nullify_flag, r1, r2, ci);
  1504.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1505.           PA_RECURSE(ADD_CO_SEQ, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1506.           if (!nullify_flag_in) PERFORM_ADD_CO_SNE(v, co, nullify_flag, r1, r2, ci);
  1507.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1508.           PA_RECURSE(ADD_CO_SNE, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1509.           if (!nullify_flag_in) PERFORM_ADD_CO_SLTU(v, co, nullify_flag, r1, r2, ci);
  1510.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1511.           PA_RECURSE(ADD_CO_SLTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1512.           if (!nullify_flag_in) PERFORM_ADD_CO_SGEU(v, co, nullify_flag, r1, r2, ci);
  1513.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1514.           PA_RECURSE(ADD_CO_SGEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1515.           if (!nullify_flag_in) PERFORM_ADD_CO_SLEU(v, co, nullify_flag, r1, r2, ci);
  1516.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1517.           PA_RECURSE(ADD_CO_SLEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1518.           if (!nullify_flag_in) PERFORM_ADD_CO_SGTU(v, co, nullify_flag, r1, r2, ci);
  1519.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1520.           PA_RECURSE(ADD_CO_SGTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1521.           if (!nullify_flag_in) PERFORM_ADD_CO_SODD(v, co, nullify_flag, r1, r2, ci);
  1522.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1523.           PA_RECURSE(ADD_CO_SODD, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1524.           if (!nullify_flag_in) PERFORM_ADD_CO_SEVN(v, co, nullify_flag, r1, r2, ci);
  1525.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1526.           PA_RECURSE(ADD_CO_SEVN, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1527.  
  1528.           /* hppa:    addl */
  1529.           if (!nullify_flag_in) PERFORM_ADD_SEQ(v, co, nullify_flag, r1, r2, ci);
  1530.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1531.           PA_RECURSE(ADD_SEQ, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1532.           if (!nullify_flag_in) PERFORM_ADD_SNE(v, co, nullify_flag, r1, r2, ci);
  1533.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1534.           PA_RECURSE(ADD_SNE, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1535.           if (!nullify_flag_in) PERFORM_ADD_SLTU(v, co, nullify_flag, r1, r2, ci);
  1536.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1537.           PA_RECURSE(ADD_SLTU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1538.           if (!nullify_flag_in) PERFORM_ADD_SGEU(v, co, nullify_flag, r1, r2, ci);
  1539.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1540.           PA_RECURSE(ADD_SGEU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1541.           if (!nullify_flag_in) PERFORM_ADD_SLEU(v, co, nullify_flag, r1, r2, ci);
  1542.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1543.           PA_RECURSE(ADD_SLEU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1544.           if (!nullify_flag_in) PERFORM_ADD_SGTU(v, co, nullify_flag, r1, r2, ci);
  1545.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1546.           PA_RECURSE(ADD_SGTU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1547.           if (!nullify_flag_in) PERFORM_ADD_SOVS(v, co, nullify_flag, r1, r2, ci);
  1548.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1549.           PA_RECURSE(ADD_SOVS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1550.           if (!nullify_flag_in) PERFORM_ADD_SNVS(v, co, nullify_flag, r1, r2, ci);
  1551.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1552.           PA_RECURSE(ADD_SNVS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1553.           if (!nullify_flag_in) PERFORM_ADD_SODD(v, co, nullify_flag, r1, r2, ci);
  1554.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1555.           PA_RECURSE(ADD_SODD, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1556.           if (!nullify_flag_in) PERFORM_ADD_SEVN(v, co, nullify_flag, r1, r2, ci);
  1557.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1558.           PA_RECURSE(ADD_SEVN, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1559.  
  1560.           /* hppa:    sub */
  1561.           if (!nullify_flag_in) PERFORM_ADC_CO_SEQ(v, co, nullify_flag, r1, r2, ci);
  1562.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1563.           PA_RECURSE(ADC_CO_SEQ, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1564.           if (!nullify_flag_in) PERFORM_ADC_CO_SNE(v, co, nullify_flag, r1, r2, ci);
  1565.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1566.           PA_RECURSE(ADC_CO_SNE, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1567.           if (!nullify_flag_in) PERFORM_ADC_CO_SLTU(v, co, nullify_flag, r1, r2, ci);
  1568.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1569.           PA_RECURSE(ADC_CO_SLTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1570.           if (!nullify_flag_in) PERFORM_ADC_CO_SGEU(v, co, nullify_flag, r1, r2, ci);
  1571.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1572.           PA_RECURSE(ADC_CO_SGEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1573.           if (!nullify_flag_in) PERFORM_ADC_CO_SLEU(v, co, nullify_flag, r1, r2, ci);
  1574.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1575.           PA_RECURSE(ADC_CO_SLEU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1576.           if (!nullify_flag_in) PERFORM_ADC_CO_SGTU(v, co, nullify_flag, r1, r2, ci);
  1577.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1578.           PA_RECURSE(ADC_CO_SGTU, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1579.           if (!nullify_flag_in) PERFORM_ADC_CO_SODD(v, co, nullify_flag, r1, r2, ci);
  1580.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1581.           PA_RECURSE(ADC_CO_SODD, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1582.           if (!nullify_flag_in) PERFORM_ADC_CO_SEVN(v, co, nullify_flag, r1, r2, ci);
  1583.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1584.           PA_RECURSE(ADC_CO_SEVN, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1585.  
  1586.           if (!nullify_flag_in) PERFORM_ADC_CO_SEQ(v, co, nullify_flag, r2, r1, ci);
  1587.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1588.           PA_RECURSE(ADC_CO_SEQ, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1589.           if (!nullify_flag_in) PERFORM_ADC_CO_SNE(v, co, nullify_flag, r2, r1, ci);
  1590.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1591.           PA_RECURSE(ADC_CO_SNE, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1592.           if (!nullify_flag_in) PERFORM_ADC_CO_SLTU(v, co, nullify_flag, r2, r1, ci);
  1593.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1594.           PA_RECURSE(ADC_CO_SLTU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1595.           if (!nullify_flag_in) PERFORM_ADC_CO_SGEU(v, co, nullify_flag, r2, r1, ci);
  1596.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1597.           PA_RECURSE(ADC_CO_SGEU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1598.           if (!nullify_flag_in) PERFORM_ADC_CO_SLEU(v, co, nullify_flag, r2, r1, ci);
  1599.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1600.           PA_RECURSE(ADC_CO_SLEU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1601.           if (!nullify_flag_in) PERFORM_ADC_CO_SGTU(v, co, nullify_flag, r2, r1, ci);
  1602.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1603.           PA_RECURSE(ADC_CO_SGTU, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1604.           if (!nullify_flag_in) PERFORM_ADC_CO_SODD(v, co, nullify_flag, r2, r1, ci);
  1605.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1606.           PA_RECURSE(ADC_CO_SODD, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1607.           if (!nullify_flag_in) PERFORM_ADC_CO_SEVN(v, co, nullify_flag, r2, r1, ci);
  1608.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1609.           PA_RECURSE(ADC_CO_SEVN, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1610.  
  1611.           /* hppa:    and */
  1612.           if (!nullify_flag_in) PERFORM_AND_SEQ(v, co, nullify_flag, r1, r2, ci);
  1613.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1614.           PA_RECURSE(AND_SEQ, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1615.           if (!nullify_flag_in) PERFORM_AND_SNE(v, co, nullify_flag, r1, r2, ci);
  1616.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1617.           PA_RECURSE(AND_SNE, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1618.           if (!nullify_flag_in) PERFORM_AND_SLTS(v, co, nullify_flag, r1, r2, ci);
  1619.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1620.           PA_RECURSE(AND_SLTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1621.           if (!nullify_flag_in) PERFORM_AND_SGES(v, co, nullify_flag, r1, r2, ci);
  1622.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1623.           PA_RECURSE(AND_SGES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1624.           if (!nullify_flag_in) PERFORM_AND_SLES(v, co, nullify_flag, r1, r2, ci);
  1625.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1626.           PA_RECURSE(AND_SLES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1627.           if (!nullify_flag_in) PERFORM_AND_SGTS(v, co, nullify_flag, r1, r2, ci);
  1628.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1629.           PA_RECURSE(AND_SGTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1630.           if (!nullify_flag_in) PERFORM_AND_SODD(v, co, nullify_flag, r1, r2, ci);
  1631.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1632.           PA_RECURSE(AND_SODD, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1633.           if (!nullify_flag_in) PERFORM_AND_SEVN(v, co, nullify_flag, r1, r2, ci);
  1634.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1635.           PA_RECURSE(AND_SEVN, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1636.  
  1637.           /* hppa:    or */
  1638.           if (!nullify_flag_in) PERFORM_IOR_SEQ(v, co, nullify_flag, r1, r2, ci);
  1639.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1640.           PA_RECURSE(IOR_SEQ, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1641.           if (!nullify_flag_in) PERFORM_IOR_SNE(v, co, nullify_flag, r1, r2, ci);
  1642.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1643.           PA_RECURSE(IOR_SNE, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1644.           if (!nullify_flag_in) PERFORM_IOR_SLTS(v, co, nullify_flag, r1, r2, ci);
  1645.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1646.           PA_RECURSE(IOR_SLTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1647.           if (!nullify_flag_in) PERFORM_IOR_SGES(v, co, nullify_flag, r1, r2, ci);
  1648.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1649.           PA_RECURSE(IOR_SGES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1650.           if (!nullify_flag_in) PERFORM_IOR_SLES(v, co, nullify_flag, r1, r2, ci);
  1651.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1652.           PA_RECURSE(IOR_SLES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1653.           if (!nullify_flag_in) PERFORM_IOR_SGTS(v, co, nullify_flag, r1, r2, ci);
  1654.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1655.           PA_RECURSE(IOR_SGTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1656.           if (!nullify_flag_in) PERFORM_IOR_SODD(v, co, nullify_flag, r1, r2, ci);
  1657.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1658.           PA_RECURSE(IOR_SODD, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1659.           if (!nullify_flag_in) PERFORM_IOR_SEVN(v, co, nullify_flag, r1, r2, ci);
  1660.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1661.           PA_RECURSE(IOR_SEVN, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1662.  
  1663.           /* hppa:    xor */
  1664.           if (!nullify_flag_in) PERFORM_XOR_SEQ(v, co, nullify_flag, r1, r2, ci);
  1665.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1666.           PA_RECURSE(XOR_SEQ, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1667.           if (!nullify_flag_in) PERFORM_XOR_SNE(v, co, nullify_flag, r1, r2, ci);
  1668.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1669.           PA_RECURSE(XOR_SNE, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1670.           if (!nullify_flag_in) PERFORM_XOR_SLTS(v, co, nullify_flag, r1, r2, ci);
  1671.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1672.           PA_RECURSE(XOR_SLTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1673.           if (!nullify_flag_in) PERFORM_XOR_SGES(v, co, nullify_flag, r1, r2, ci);
  1674.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1675.           PA_RECURSE(XOR_SGES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1676.           if (!nullify_flag_in) PERFORM_XOR_SLES(v, co, nullify_flag, r1, r2, ci);
  1677.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1678.           PA_RECURSE(XOR_SLES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1679.           if (!nullify_flag_in) PERFORM_XOR_SGTS(v, co, nullify_flag, r1, r2, ci);
  1680.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1681.           PA_RECURSE(XOR_SGTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1682.           if (!nullify_flag_in) PERFORM_XOR_SODD(v, co, nullify_flag, r1, r2, ci);
  1683.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1684.           PA_RECURSE(XOR_SODD, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1685.           if (!nullify_flag_in) PERFORM_XOR_SEVN(v, co, nullify_flag, r1, r2, ci);
  1686.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1687.           PA_RECURSE(XOR_SEVN, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1688.  
  1689.           /* hppa:    andcm */
  1690.           if (!nullify_flag_in) PERFORM_ANDC_SEQ(v, co, nullify_flag, r1, r2, ci);
  1691.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1692.           PA_RECURSE(ANDC_SEQ, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1693.           if (!nullify_flag_in) PERFORM_ANDC_SNE(v, co, nullify_flag, r1, r2, ci);
  1694.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1695.           PA_RECURSE(ANDC_SNE, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1696.           if (!nullify_flag_in) PERFORM_ANDC_SLTS(v, co, nullify_flag, r1, r2, ci);
  1697.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1698.           PA_RECURSE(ANDC_SLTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1699.           if (!nullify_flag_in) PERFORM_ANDC_SGES(v, co, nullify_flag, r1, r2, ci);
  1700.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1701.           PA_RECURSE(ANDC_SGES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1702.           if (!nullify_flag_in) PERFORM_ANDC_SLES(v, co, nullify_flag, r1, r2, ci);
  1703.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1704.           PA_RECURSE(ANDC_SLES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1705.           if (!nullify_flag_in) PERFORM_ANDC_SGTS(v, co, nullify_flag, r1, r2, ci);
  1706.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1707.           PA_RECURSE(ANDC_SGTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1708.           if (!nullify_flag_in) PERFORM_ANDC_SODD(v, co, nullify_flag, r1, r2, ci);
  1709.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1710.           PA_RECURSE(ANDC_SODD, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1711.           if (!nullify_flag_in) PERFORM_ANDC_SEVN(v, co, nullify_flag, r1, r2, ci);
  1712.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1713.           PA_RECURSE(ANDC_SEVN, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1714.           if (!nullify_flag_in) PERFORM_ANDC_SEQ(v, co, nullify_flag, r2, r1, ci);
  1715.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1716.           PA_RECURSE(ANDC_SEQ, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1717.           if (!nullify_flag_in) PERFORM_ANDC_SNE(v, co, nullify_flag, r2, r1, ci);
  1718.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1719.           PA_RECURSE(ANDC_SNE, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1720.           if (!nullify_flag_in) PERFORM_ANDC_SLTS(v, co, nullify_flag, r2, r1, ci);
  1721.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1722.           PA_RECURSE(ANDC_SLTS, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1723.           if (!nullify_flag_in) PERFORM_ANDC_SGES(v, co, nullify_flag, r2, r1, ci);
  1724.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1725.           PA_RECURSE(ANDC_SGES, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1726.           if (!nullify_flag_in) PERFORM_ANDC_SLES(v, co, nullify_flag, r2, r1, ci);
  1727.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1728.           PA_RECURSE(ANDC_SLES, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1729.           if (!nullify_flag_in) PERFORM_ANDC_SGTS(v, co, nullify_flag, r2, r1, ci);
  1730.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1731.           PA_RECURSE(ANDC_SGTS, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1732.           if (!nullify_flag_in) PERFORM_ANDC_SODD(v, co, nullify_flag, r2, r1, ci);
  1733.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1734.           PA_RECURSE(ANDC_SODD, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1735.           if (!nullify_flag_in) PERFORM_ANDC_SEVN(v, co, nullify_flag, r2, r1, ci);
  1736.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1737.           PA_RECURSE(ANDC_SEVN, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1738.  
  1739.           /* comclr instructions.  We don't commute the operands here,
  1740.          since e.g. r1<r2 is the same as r2>r1.  */
  1741.           /* hppa:    comclr,= */
  1742.           if (!nullify_flag_in) PERFORM_COMCLR_SEQ(v, co, nullify_flag, r1, r2, ci);
  1743.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1744.           PA_RECURSE(COMCLR_SEQ, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1745.           /* hppa:    comclr,<> */
  1746.           if (!nullify_flag_in) PERFORM_COMCLR_SNE(v, co, nullify_flag, r1, r2, ci);
  1747.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1748.           PA_RECURSE(COMCLR_SNE, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1749.           /* hppa:    comclr,< */
  1750.           if (!nullify_flag_in) PERFORM_COMCLR_SLTS(v, co, nullify_flag, r1, r2, ci);
  1751.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1752.           PA_RECURSE(COMCLR_SLTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1753.           /* hppa:    comclr,>= */
  1754.           if (!nullify_flag_in) PERFORM_COMCLR_SGES(v, co, nullify_flag, r1, r2, ci);
  1755.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1756.           PA_RECURSE(COMCLR_SGES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1757.           /* hppa:    comclr,<= */
  1758.           if (!nullify_flag_in) PERFORM_COMCLR_SLES(v, co, nullify_flag, r1, r2, ci);
  1759.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1760.           PA_RECURSE(COMCLR_SLES, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1761.           /* hppa:    comclr,> */
  1762.           if (!nullify_flag_in) PERFORM_COMCLR_SGTS(v, co, nullify_flag, r1, r2, ci);
  1763.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1764.           PA_RECURSE(COMCLR_SGTS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1765.           /* hppa:    comclr,<< */
  1766.           if (!nullify_flag_in) PERFORM_COMCLR_SLTU(v, co, nullify_flag, r1, r2, ci);
  1767.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1768.           PA_RECURSE(COMCLR_SLTU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1769.           /* hppa:    comclr,>>= */
  1770.           if (!nullify_flag_in) PERFORM_COMCLR_SGEU(v, co, nullify_flag, r1, r2, ci);
  1771.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1772.           PA_RECURSE(COMCLR_SGEU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1773.           /* hppa:    comclr,<<= */
  1774.           if (!nullify_flag_in) PERFORM_COMCLR_SLEU(v, co, nullify_flag, r1, r2, ci);
  1775.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1776.           PA_RECURSE(COMCLR_SLEU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1777.           /* hppa:    comclr,>> */
  1778.           if (!nullify_flag_in) PERFORM_COMCLR_SGTU(v, co, nullify_flag, r1, r2, ci);
  1779.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1780.           PA_RECURSE(COMCLR_SGTU, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1781. #if LATER
  1782.           /* Do we need both commutations here??? */
  1783.           /* hppa:    comclr,sv */
  1784.           if (!nullify_flag_in) PERFORM_COMCLR_SOVS(v, co, nullify_flag, r1, r2, ci);
  1785.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1786.           PA_RECURSE(COMCLR_SOVS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1787.           if (!nullify_flag_in) PERFORM_COMCLR_SOVS(v, co, nullify_flag, r2, r1, ci);
  1788.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1789.           PA_RECURSE(COMCLR_SOVS, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1790.  
  1791.           /* hppa:    comclr,nsv */
  1792.           if (!nullify_flag_in) PERFORM_COMCLR_SNVS(v, co, nullify_flag, r1, r2, ci);
  1793.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1794.           PA_RECURSE(COMCLR_SNVS, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1795.           if (!nullify_flag_in) PERFORM_COMCLR_SNVS(v, co, nullify_flag, r2, r1, ci);
  1796.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1797.           PA_RECURSE(COMCLR_SNVS, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1798. #endif
  1799.           /* hppa:    comclr,od */
  1800.           if (!nullify_flag_in) PERFORM_COMCLR_SODD(v, co, nullify_flag, r1, r2, ci);
  1801.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1802.           PA_RECURSE(COMCLR_SODD, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1803.           /* hppa:    comclr,ev */
  1804.           if (!nullify_flag_in) PERFORM_COMCLR_SEVN(v, co, nullify_flag, r1, r2, ci);
  1805.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1806.           PA_RECURSE(COMCLR_SEVN, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1807.         }
  1808.     }
  1809.     }
  1810.  
  1811.   /* Unary operations with carry-in.  */
  1812.   if (ci >= 0 && flag_use_carry)
  1813.     {
  1814.       for (s1 = n_values - 1; s1 >= 0; s1--)
  1815.     {
  1816.       r1 = values[s1];
  1817.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1818.       for (dr = n_values; dr >= dr_lim; dr--)
  1819.         {
  1820.           /* d,cy = 2*r1 + cy
  1821.          hppa:    addc    s1,s1,d */
  1822.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEQ(v, co, nullify_flag, r1, r1, ci);
  1823.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1824.           PA_RECURSE(ADD_CIO_SEQ, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1825.           if (!nullify_flag_in) PERFORM_ADD_CIO_SNE(v, co, nullify_flag, r1, r1, ci);
  1826.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1827.           PA_RECURSE(ADD_CIO_SNE, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1828.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLTU(v, co, nullify_flag, r1, r1, ci);
  1829.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1830.           PA_RECURSE(ADD_CIO_SLTU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1831.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGEU(v, co, nullify_flag, r1, r1, ci);
  1832.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1833.           PA_RECURSE(ADD_CIO_SGEU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1834.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLEU(v, co, nullify_flag, r1, r1, ci);
  1835.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1836.           PA_RECURSE(ADD_CIO_SLEU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1837.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGTU(v, co, nullify_flag, r1, r1, ci);
  1838.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1839.           PA_RECURSE(ADD_CIO_SGTU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1840.           if (!nullify_flag_in) PERFORM_ADD_CIO_SODD(v, co, nullify_flag, r1, r1, ci);
  1841.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1842.           PA_RECURSE(ADD_CIO_SODD, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1843.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEVN(v, co, nullify_flag, r1, r1, ci);
  1844.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1845.           PA_RECURSE(ADD_CIO_SEVN, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1846.  
  1847.           /* d,cy = r1 + cy - 1
  1848.          hppa:    subb    s1,r0,d */
  1849.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEQ(v, co, nullify_flag, r1, VALUE(-1), ci);
  1850.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1851.           PA_RECURSE(ADD_CIO_SEQ, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1852.           if (!nullify_flag_in) PERFORM_ADD_CIO_SNE(v, co, nullify_flag, r1, VALUE(-1), ci);
  1853.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1854.           PA_RECURSE(ADD_CIO_SNE, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1855.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLTU(v, co, nullify_flag, r1, VALUE(-1), ci);
  1856.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1857.           PA_RECURSE(ADD_CIO_SLTU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1858.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGEU(v, co, nullify_flag, r1, VALUE(-1), ci);
  1859.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1860.           PA_RECURSE(ADD_CIO_SGEU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1861.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLEU(v, co, nullify_flag, r1, VALUE(-1), ci);
  1862.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1863.           PA_RECURSE(ADD_CIO_SLEU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1864.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGTU(v, co, nullify_flag, r1, VALUE(-1), ci);
  1865.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1866.           PA_RECURSE(ADD_CIO_SGTU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1867.           if (!nullify_flag_in) PERFORM_ADD_CIO_SODD(v, co, nullify_flag, r1, VALUE(-1), ci);
  1868.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1869.           PA_RECURSE(ADD_CIO_SODD, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1870.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEVN(v, co, nullify_flag, r1, VALUE(-1), ci);
  1871.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1872.           PA_RECURSE(ADD_CIO_SEVN, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1873.  
  1874.           /* d,cy = r1 + cy
  1875.          hppa:    addc    s1,r0,d */
  1876.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEQ(v, co, nullify_flag, r1, VALUE(0), ci);
  1877.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1878.           PA_RECURSE(ADD_CIO_SEQ, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1879.           if (!nullify_flag_in) PERFORM_ADD_CIO_SNE(v, co, nullify_flag, r1, VALUE(0), ci);
  1880.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1881.           PA_RECURSE(ADD_CIO_SNE, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1882.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLTU(v, co, nullify_flag, r1, VALUE(0), ci);
  1883.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1884.           PA_RECURSE(ADD_CIO_SLTU, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1885.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGEU(v, co, nullify_flag, r1, VALUE(0), ci);
  1886.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1887.           PA_RECURSE(ADD_CIO_SGEU, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1888.           if (!nullify_flag_in) PERFORM_ADD_CIO_SLEU(v, co, nullify_flag, r1, VALUE(0), ci);
  1889.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1890.           PA_RECURSE(ADD_CIO_SLEU, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1891.           if (!nullify_flag_in) PERFORM_ADD_CIO_SGTU(v, co, nullify_flag, r1, VALUE(0), ci);
  1892.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1893.           PA_RECURSE(ADD_CIO_SGTU, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1894.           if (!nullify_flag_in) PERFORM_ADD_CIO_SODD(v, co, nullify_flag, r1, VALUE(0), ci);
  1895.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1896.           PA_RECURSE(ADD_CIO_SODD, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1897.           if (!nullify_flag_in) PERFORM_ADD_CIO_SEVN(v, co, nullify_flag, r1, VALUE(0), ci);
  1898.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1899.           PA_RECURSE(ADD_CIO_SEVN, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1900.  
  1901.           /* d,cy = ~r1 + cy
  1902.          hppa:    subb    r0,s1,d */
  1903.           if (!nullify_flag_in) PERFORM_ADC_CIO_SEQ(v, co, nullify_flag, VALUE(0), r1, ci);
  1904.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1905.           PA_RECURSE(ADC_CIO_SEQ, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1906.           if (!nullify_flag_in) PERFORM_ADC_CIO_SNE(v, co, nullify_flag, VALUE(0), r1, ci);
  1907.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1908.           PA_RECURSE(ADC_CIO_SNE, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1909.           if (!nullify_flag_in) PERFORM_ADC_CIO_SLTU(v, co, nullify_flag, VALUE(0), r1, ci);
  1910.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1911.           PA_RECURSE(ADC_CIO_SLTU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1912.           if (!nullify_flag_in) PERFORM_ADC_CIO_SGEU(v, co, nullify_flag, VALUE(0), r1, ci);
  1913.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1914.           PA_RECURSE(ADC_CIO_SGEU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1915.           if (!nullify_flag_in) PERFORM_ADC_CIO_SLEU(v, co, nullify_flag, VALUE(0), r1, ci);
  1916.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1917.           PA_RECURSE(ADC_CIO_SLEU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1918.           if (!nullify_flag_in) PERFORM_ADC_CIO_SGTU(v, co, nullify_flag, VALUE(0), r1, ci);
  1919.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1920.           PA_RECURSE(ADC_CIO_SGTU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1921.           if (!nullify_flag_in) PERFORM_ADC_CIO_SODD(v, co, nullify_flag, VALUE(0), r1, ci);
  1922.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1923.           PA_RECURSE(ADC_CIO_SODD, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1924.           if (!nullify_flag_in) PERFORM_ADC_CIO_SEVN(v, co, nullify_flag, VALUE(0), r1, ci);
  1925.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1926.           PA_RECURSE(ADC_CIO_SEVN, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1927.         }
  1928.     }
  1929.     }
  1930.  
  1931.   /* Unary operations without carry-in.  */
  1932.   for (s1 = n_values - 1; s1 >= 0; s1--)
  1933.     {
  1934.       r1 = values[s1];
  1935.       dr_lim = prune_hint & NULLIFYING_INSN ? 0 : n_values;
  1936.       for (dr = n_values; dr >= dr_lim; dr--)
  1937.     {
  1938.       /* d,cy = 2*r1
  1939.          hppa:        add    s1,s1,d */
  1940.       if (!nullify_flag_in) PERFORM_ADD_CO_SEQ(v, co, nullify_flag, r1, r1, ci);
  1941.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1942.       PA_RECURSE(ADD_CO_SEQ, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1943.       if (!nullify_flag_in) PERFORM_ADD_CO_SNE(v, co, nullify_flag, r1, r1, ci);
  1944.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1945.       PA_RECURSE(ADD_CO_SNE, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1946.       if (!nullify_flag_in) PERFORM_ADD_CO_SLTU(v, co, nullify_flag, r1, r1, ci);
  1947.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1948.       PA_RECURSE(ADD_CO_SLTU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1949.       if (!nullify_flag_in) PERFORM_ADD_CO_SGEU(v, co, nullify_flag, r1, r1, ci);
  1950.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1951.       PA_RECURSE(ADD_CO_SGEU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1952.       if (!nullify_flag_in) PERFORM_ADD_CO_SLEU(v, co, nullify_flag, r1, r1, ci);
  1953.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1954.       PA_RECURSE(ADD_CO_SLEU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1955.       if (!nullify_flag_in) PERFORM_ADD_CO_SGTU(v, co, nullify_flag, r1, r1, ci);
  1956.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1957.       PA_RECURSE(ADD_CO_SGTU, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1958.       if (!nullify_flag_in) PERFORM_ADD_CO_SODD(v, co, nullify_flag, r1, r1, ci);
  1959.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1960.       PA_RECURSE(ADD_CO_SODD, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1961.       if (!nullify_flag_in) PERFORM_ADD_CO_SEVN(v, co, nullify_flag, r1, r1, ci);
  1962.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1963.       PA_RECURSE(ADD_CO_SEVN, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  1964.  
  1965.       /* d = r1 & 1
  1966.          hppa:        extru    s1,31,1,d */
  1967.       if (!nullify_flag_in) PERFORM_AND_SEQ(v, co, nullify_flag, r1, VALUE(1), ci);
  1968.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1969.       PA_RECURSE(AND_SEQ, dr, s1, CNST(1), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1970.       if (!nullify_flag_in) PERFORM_AND_SNE(v, co, nullify_flag, r1, VALUE(1), ci);
  1971.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1972.       PA_RECURSE(AND_SNE, dr, s1, CNST(1), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1973.       /* All other conditions are trivial (or repetitions). */
  1974.  
  1975.       /* d = r1 & 0x7fffffff
  1976.          hppa:        extru    s1,31,31,d */
  1977.       if (!nullify_flag_in) PERFORM_AND_SEQ(v, co, nullify_flag, r1, VALUE_MAX_SIGNED, ci);
  1978.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1979.       PA_RECURSE(AND_SEQ, dr, s1, CNST_0x7FFFFFFF, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1980.       if (!nullify_flag_in) PERFORM_AND_SNE(v, co, nullify_flag, r1, VALUE_MAX_SIGNED, ci);
  1981.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1982.       PA_RECURSE(AND_SNE, dr, s1, CNST_0x7FFFFFFF, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1983.       if (!nullify_flag_in) PERFORM_AND_SODD(v, co, nullify_flag, r1, VALUE_MAX_SIGNED, ci);
  1984.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1985.       PA_RECURSE(AND_SODD, dr, s1, CNST_0x7FFFFFFF, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1986.       if (!nullify_flag_in) PERFORM_AND_SEVN(v, co, nullify_flag, r1, VALUE_MAX_SIGNED, ci);
  1987.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1988.       PA_RECURSE(AND_SEVN, dr, s1, CNST_0x7FFFFFFF, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1989.       /* All other conditions are trivial (or repetitions). */
  1990.  
  1991.       /* d = ~r1
  1992.          hppa:        andcm    r0,s1,d */
  1993.       if (!nullify_flag_in) PERFORM_SUB_SEQ(v, co, nullify_flag, VALUE(-1), r1, ci);
  1994.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1995.       PA_RECURSE(SUB_SEQ, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1996.       if (!nullify_flag_in) PERFORM_SUB_SNE(v, co, nullify_flag, VALUE(-1), r1, ci);
  1997.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  1998.       PA_RECURSE(SUB_SNE, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  1999.       if (!nullify_flag_in) PERFORM_SUB_SLTS(v, co, nullify_flag, VALUE(-1), r1, ci);
  2000.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2001.       PA_RECURSE(SUB_SLTS, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2002.       if (!nullify_flag_in) PERFORM_SUB_SGES(v, co, nullify_flag, VALUE(-1), r1, ci);
  2003.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2004.       PA_RECURSE(SUB_SGES, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2005.       if (!nullify_flag_in) PERFORM_SUB_SLES(v, co, nullify_flag, VALUE(-1), r1, ci);
  2006.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2007.       PA_RECURSE(SUB_SLES, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2008.       if (!nullify_flag_in) PERFORM_SUB_SGTS(v, co, nullify_flag, VALUE(-1), r1, ci);
  2009.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2010.       PA_RECURSE(SUB_SGTS, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2011.       if (!nullify_flag_in) PERFORM_SUB_SODD(v, co, nullify_flag, VALUE(-1), r1, ci);
  2012.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2013.       PA_RECURSE(SUB_SODD, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2014.       if (!nullify_flag_in) PERFORM_SUB_SEVN(v, co, nullify_flag, VALUE(-1), r1, ci);
  2015.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2016.       PA_RECURSE(SUB_SEVN, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2017.  
  2018.       /* d,cy = -1 + ~r1 + 1 (i.e. one's complement and set carry.);
  2019.          hppa:    subi    -1,s1,d */
  2020.       if (!nullify_flag_in) PERFORM_ADC_CO_SEQ(v, co, nullify_flag, VALUE(-1), r1, ci);
  2021.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2022.       PA_RECURSE(ADC_CO_SEQ, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2023.       if (!nullify_flag_in) PERFORM_ADC_CO_SNE(v, co, nullify_flag, VALUE(-1), r1, ci);
  2024.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2025.       PA_RECURSE(ADC_CO_SNE, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2026.       if (!nullify_flag_in) PERFORM_ADC_CO_SLTU(v, co, nullify_flag, VALUE(-1), r1, ci);
  2027.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2028.       PA_RECURSE(ADC_CO_SLTU, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2029.       if (!nullify_flag_in) PERFORM_ADC_CO_SGEU(v, co, nullify_flag, VALUE(-1), r1, ci);
  2030.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2031.       PA_RECURSE(ADC_CO_SGEU, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2032.       if (!nullify_flag_in) PERFORM_ADC_CO_SLEU(v, co, nullify_flag, VALUE(-1), r1, ci);
  2033.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2034.       PA_RECURSE(ADC_CO_SLEU, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2035.       if (!nullify_flag_in) PERFORM_ADC_CO_SGTU(v, co, nullify_flag, VALUE(-1), r1, ci);
  2036.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2037.       PA_RECURSE(ADC_CO_SGTU, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2038.       if (!nullify_flag_in) PERFORM_ADC_CO_SODD(v, co, nullify_flag, VALUE(-1), r1, ci);
  2039.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2040.       PA_RECURSE(ADC_CO_SODD, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2041.       if (!nullify_flag_in) PERFORM_ADC_CO_SEVN(v, co, nullify_flag, VALUE(-1), r1, ci);
  2042.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2043.       PA_RECURSE(ADC_CO_SEVN, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2044.  
  2045.       /* d,cy = r1 + 1
  2046.          hppa:        addi    1,s1,d */
  2047.       if (!nullify_flag_in) PERFORM_ADD_CO_SEQ(v, co, nullify_flag, r1, VALUE(1), ci);
  2048.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2049.       PA_RECURSE(ADD_CO_SEQ, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2050.       if (!nullify_flag_in) PERFORM_ADD_CO_SNE(v, co, nullify_flag, r1, VALUE(1), ci);
  2051.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2052.       PA_RECURSE(ADD_CO_SNE, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2053.       if (!nullify_flag_in) PERFORM_ADD_CO_SLTU(v, co, nullify_flag, r1, VALUE(1), ci);
  2054.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2055.       PA_RECURSE(ADD_CO_SLTU, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2056.       if (!nullify_flag_in) PERFORM_ADD_CO_SGEU(v, co, nullify_flag, r1, VALUE(1), ci);
  2057.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2058.       PA_RECURSE(ADD_CO_SGEU, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2059.       if (!nullify_flag_in) PERFORM_ADD_CO_SLEU(v, co, nullify_flag, r1, VALUE(1), ci);
  2060.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2061.       PA_RECURSE(ADD_CO_SLEU, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2062.       if (!nullify_flag_in) PERFORM_ADD_CO_SGTU(v, co, nullify_flag, r1, VALUE(1), ci);
  2063.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2064.       PA_RECURSE(ADD_CO_SGTU, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2065.       if (!nullify_flag_in) PERFORM_ADD_CO_SODD(v, co, nullify_flag, r1, VALUE(1), ci);
  2066.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2067.       PA_RECURSE(ADD_CO_SODD, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2068.       if (!nullify_flag_in) PERFORM_ADD_CO_SEVN(v, co, nullify_flag, r1, VALUE(1), ci);
  2069.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2070.       PA_RECURSE(ADD_CO_SEVN, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2071.  
  2072.       /* d,cy = r1 + -1
  2073.          hppa:        addi    -1,s1,d */
  2074.       if (!nullify_flag_in) PERFORM_ADD_CO_SEQ(v, co, nullify_flag, r1, VALUE(-1), ci);
  2075.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2076.       PA_RECURSE(ADD_CO_SEQ, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2077.       if (!nullify_flag_in) PERFORM_ADD_CO_SNE(v, co, nullify_flag, r1, VALUE(-1), ci);
  2078.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2079.       PA_RECURSE(ADD_CO_SNE, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2080.       if (!nullify_flag_in) PERFORM_ADD_CO_SLTU(v, co, nullify_flag, r1, VALUE(-1), ci);
  2081.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2082.       PA_RECURSE(ADD_CO_SLTU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2083.       if (!nullify_flag_in) PERFORM_ADD_CO_SGEU(v, co, nullify_flag, r1, VALUE(-1), ci);
  2084.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2085.       PA_RECURSE(ADD_CO_SGEU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2086.       if (!nullify_flag_in) PERFORM_ADD_CO_SLEU(v, co, nullify_flag, r1, VALUE(-1), ci);
  2087.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2088.       PA_RECURSE(ADD_CO_SLEU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2089.       if (!nullify_flag_in) PERFORM_ADD_CO_SGTU(v, co, nullify_flag, r1, VALUE(-1), ci);
  2090.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2091.       PA_RECURSE(ADD_CO_SGTU, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2092.       if (!nullify_flag_in) PERFORM_ADD_CO_SODD(v, co, nullify_flag, r1, VALUE(-1), ci);
  2093.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2094.       PA_RECURSE(ADD_CO_SODD, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2095.       if (!nullify_flag_in) PERFORM_ADD_CO_SEVN(v, co, nullify_flag, r1, VALUE(-1), ci);
  2096.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2097.       PA_RECURSE(ADD_CO_SEVN, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2098.  
  2099.       /* d,cy = -r1
  2100.          hppa:        subi    0,s1,d */
  2101.       if (!nullify_flag_in) PERFORM_ADC_CO_SEQ(v, co, nullify_flag, VALUE(0), r1, ci);
  2102.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2103.       PA_RECURSE(ADC_CO_SEQ, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2104.       if (!nullify_flag_in) PERFORM_ADC_CO_SNE(v, co, nullify_flag, VALUE(0), r1, ci);
  2105.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2106.       PA_RECURSE(ADC_CO_SNE, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2107.       if (!nullify_flag_in) PERFORM_ADC_CO_SLTU(v, co, nullify_flag, VALUE(0), r1, ci);
  2108.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2109.       PA_RECURSE(ADC_CO_SLTU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2110.       if (!nullify_flag_in) PERFORM_ADC_CO_SGEU(v, co, nullify_flag, VALUE(0), r1, ci);
  2111.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2112.       PA_RECURSE(ADC_CO_SGEU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2113.       if (!nullify_flag_in) PERFORM_ADC_CO_SLEU(v, co, nullify_flag, VALUE(0), r1, ci);
  2114.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2115.       PA_RECURSE(ADC_CO_SLEU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2116.       if (!nullify_flag_in) PERFORM_ADC_CO_SGTU(v, co, nullify_flag, VALUE(0), r1, ci);
  2117.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2118.       PA_RECURSE(ADC_CO_SGTU, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2119.       if (!nullify_flag_in) PERFORM_ADC_CO_SODD(v, co, nullify_flag, VALUE(0), r1, ci);
  2120.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2121.       PA_RECURSE(ADC_CO_SODD, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2122.       if (!nullify_flag_in) PERFORM_ADC_CO_SEVN(v, co, nullify_flag, VALUE(0), r1, ci);
  2123.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2124.       PA_RECURSE(ADC_CO_SEVN, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2125.  
  2126.       /* comiclr instructions.  We don't commute the operands here,
  2127.          since e.g. r1<r2 is the same as r2>r1.  */
  2128.       /* with 0 */
  2129.       /* hppa:    comclr,= */
  2130.       if (!nullify_flag_in) PERFORM_COMCLR_SEQ(v, co, nullify_flag, VALUE(0), r1, ci);
  2131.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2132.       PA_RECURSE(COMCLR_SEQ, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2133.       /* hppa:    comclr,<> */
  2134.       if (!nullify_flag_in) PERFORM_COMCLR_SNE(v, co, nullify_flag, VALUE(0), r1, ci);
  2135.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2136.       PA_RECURSE(COMCLR_SNE, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2137.       /* hppa:    comclr,< */
  2138.       if (!nullify_flag_in) PERFORM_COMCLR_SLTS(v, co, nullify_flag, VALUE(0), r1, ci);
  2139.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2140.       PA_RECURSE(COMCLR_SLTS, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2141.       /* hppa:    comclr,>= */
  2142.       if (!nullify_flag_in) PERFORM_COMCLR_SGES(v, co, nullify_flag, VALUE(0), r1, ci);
  2143.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2144.       PA_RECURSE(COMCLR_SGES, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2145.       /* hppa:    comclr,<= */
  2146.       if (!nullify_flag_in) PERFORM_COMCLR_SLES(v, co, nullify_flag, VALUE(0), r1, ci);
  2147.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2148.       PA_RECURSE(COMCLR_SLES, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2149.       /* hppa:    comclr,> */
  2150.       if (!nullify_flag_in) PERFORM_COMCLR_SGTS(v, co, nullify_flag, VALUE(0), r1, ci);
  2151.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2152.       PA_RECURSE(COMCLR_SGTS, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2153.       /* hppa:    comclr,<< */
  2154.       if (!nullify_flag_in) PERFORM_COMCLR_SLTU(v, co, nullify_flag, VALUE(0), r1, ci);
  2155.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2156.       PA_RECURSE(COMCLR_SLTU, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2157.       /* hppa:    comclr,>>= */
  2158.       if (!nullify_flag_in) PERFORM_COMCLR_SGEU(v, co, nullify_flag, VALUE(0), r1, ci);
  2159.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2160.       PA_RECURSE(COMCLR_SGEU, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2161.       /* hppa:    comclr,<<= */
  2162.       if (!nullify_flag_in) PERFORM_COMCLR_SLEU(v, co, nullify_flag, VALUE(0), r1, ci);
  2163.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2164.       PA_RECURSE(COMCLR_SLEU, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2165.       /* hppa:    comclr,>> */
  2166.       if (!nullify_flag_in) PERFORM_COMCLR_SGTU(v, co, nullify_flag, VALUE(0), r1, ci);
  2167.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2168.       PA_RECURSE(COMCLR_SGTU, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2169.  
  2170.       /* with -1 */
  2171.       /* hppa:    comclr,= */
  2172.       if (!nullify_flag_in) PERFORM_COMCLR_SEQ(v, co, nullify_flag, VALUE(-1), r1, ci);
  2173.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2174.       PA_RECURSE(COMCLR_SEQ, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2175.       /* hppa:    comclr,<> */
  2176.       if (!nullify_flag_in) PERFORM_COMCLR_SNE(v, co, nullify_flag, VALUE(-1), r1, ci);
  2177.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2178.       PA_RECURSE(COMCLR_SNE, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2179.       /* hppa:    comclr,< -1,r,d == comclr,<= 0,r,d */
  2180.       /* hppa:    comclr,>= -1,r,d == comclr,> 0,r,d */
  2181.       /* hppa:    comclr,<= -1,r,d */
  2182.       if (!nullify_flag_in) PERFORM_COMCLR_SLES(v, co, nullify_flag, VALUE(-1), r1, ci);
  2183.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2184.       PA_RECURSE(COMCLR_SLES, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2185.       /* hppa:    comclr,> -1,r,d */
  2186.       if (!nullify_flag_in) PERFORM_COMCLR_SGTS(v, co, nullify_flag, VALUE(-1), r1, ci);
  2187.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2188.       PA_RECURSE(COMCLR_SGTS, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2189.       /* hppa:    comclr,<< -1,r,d is never true */
  2190.       /* hppa:    comclr,>>= -1,r,d is always true */
  2191.       /* hppa:    comclr,<<= -1,r,d == comclr,= -1,r,d */
  2192.       /* hppa:    comclr,>> -1,r,d == comclr,<> -1,r,d*/
  2193.  
  2194.       /* with 1 */
  2195.       /* hppa:    comclr,= */
  2196.       if (!nullify_flag_in) PERFORM_COMCLR_SEQ(v, co, nullify_flag, VALUE(1), r1, ci);
  2197.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2198.       PA_RECURSE(COMCLR_SEQ, dr, CNST(1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2199.       /* hppa:    comclr,<> */
  2200.       if (!nullify_flag_in) PERFORM_COMCLR_SNE(v, co, nullify_flag, VALUE(1), r1, ci);
  2201.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2202.       PA_RECURSE(COMCLR_SNE, dr, CNST(1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2203.       /* hppa:    comclr,< 1,r,d */
  2204.       if (!nullify_flag_in) PERFORM_COMCLR_SLTS(v, co, nullify_flag, VALUE(1), r1, ci);
  2205.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2206.       PA_RECURSE(COMCLR_SLTS, dr, CNST(1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2207.       /* hppa:    comclr,>= 1,r,d */
  2208.       if (!nullify_flag_in) PERFORM_COMCLR_SGES(v, co, nullify_flag, VALUE(1), r1, ci);
  2209.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2210.       PA_RECURSE(COMCLR_SGES, dr, CNST(1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2211.       /* hppa:    comclr,<= 1,r,d == comclr,< 0,r,d */
  2212.       /* hppa:    comclr,> 1,r,d == comclr,>= 0,r,d */
  2213.       /* hppa:    comclr,<< 1,r,d */
  2214.       if (!nullify_flag_in) PERFORM_COMCLR_SLTU(v, co, nullify_flag, VALUE(1), r1, ci);
  2215.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2216.       PA_RECURSE(COMCLR_SLTU, dr, CNST(1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2217.       /* hppa:    comclr,>>= 1,r,d */
  2218.       if (!nullify_flag_in) PERFORM_COMCLR_SGEU(v, co, nullify_flag, VALUE(1), r1, ci);
  2219.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2220.       PA_RECURSE(COMCLR_SGEU, dr, CNST(1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2221.       /* hppa:    comclr,<<= 1,r,d == comclr,<< 0,r,d */
  2222.       /* hppa:    comclr,>> 1,r,d == comclr,>>= 0,r,d */
  2223. #if LATER
  2224.       /* Do we need both commutations here??? */
  2225.       /* hppa:    comclr,sv */
  2226.       if (!nullify_flag_in) PERFORM_COMCLR_SOVS(v, co, nullify_flag, VALUE(0), r1, ci);
  2227.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2228.       PA_RECURSE(COMCLR_SOVS, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2229.       if (!nullify_flag_in) PERFORM_COMCLR_SOVS(v, co, nullify_flag, VALUE(0), r1, ci);
  2230.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2231.       PA_RECURSE(COMCLR_SOVS, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2232.  
  2233.       /* hppa:    comclr,nsv */
  2234.       if (!nullify_flag_in) PERFORM_COMCLR_SNVS(v, co, nullify_flag, VALUE(0), r1, ci);
  2235.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2236.       PA_RECURSE(COMCLR_SNVS, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2237.       if (!nullify_flag_in) PERFORM_COMCLR_SNVS(v, co, nullify_flag, VALUE(0), r1, ci);
  2238.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2239.       PA_RECURSE(COMCLR_SNVS, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2240. #endif
  2241.       /* hppa:    comclr,od */
  2242.       if (!nullify_flag_in) PERFORM_COMCLR_SODD(v, co, nullify_flag, VALUE(0), r1, ci);
  2243.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2244.       PA_RECURSE(COMCLR_SODD, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2245.       /* hppa:    comclr,ev */
  2246.       if (!nullify_flag_in) PERFORM_COMCLR_SEVN(v, co, nullify_flag, VALUE(0), r1, ci);
  2247.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2248.       PA_RECURSE(COMCLR_SEVN, dr, CNST(0), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2249.     }
  2250.     }
  2251. }
  2252.  
  2253. void
  2254. synth_skip (insn_t *sequence,
  2255.         int n_insns,
  2256.         word *values,
  2257.         int n_values,
  2258.         word goal_value,
  2259.         int allowed_cost,
  2260.         int ci,
  2261.         int prune_hint,
  2262.         int nullify_flag_in)
  2263. {
  2264.   int s1, s2;
  2265.   word v, r1, r2;
  2266.   int co;
  2267.   int last_dest;
  2268.   int dr;
  2269.   int nullify_flag;
  2270.  
  2271.   if (n_insns > 0)
  2272.     last_dest = sequence[n_insns - 1].d;
  2273.   else
  2274.     last_dest = -1;
  2275.  
  2276.   /* Binary operations with carry-in.  */
  2277.   if (ci >= 0 && flag_use_carry)
  2278.     {
  2279.       for (s1 = n_values - 1; s1 >= 0; s1--)
  2280.     {
  2281.       r1 = values[s1];
  2282.       for (s2 = s1 - 1; s2 >= 0; s2--)
  2283.         {
  2284.           r2 = values[s2];
  2285.           for (dr = n_values; dr >= 0; dr--)
  2286.         {
  2287.           /* hppa:        addc */
  2288.           if (!nullify_flag_in) PERFORM_ADD_CIO_S(v, co, nullify_flag, r1, r2, ci);
  2289.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2290.           PA_RECURSE(ADD_CIO_S, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2291.  
  2292.           /* hppa:        subb */
  2293.           if (!nullify_flag_in) PERFORM_ADC_CIO_S(v, co, nullify_flag, r1, r2, ci);
  2294.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2295.           PA_RECURSE(ADC_CIO_S, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2296.  
  2297.           if (!nullify_flag_in) PERFORM_ADC_CIO_S(v, co, nullify_flag, r2, r1, ci);
  2298.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2299.           PA_RECURSE(ADC_CIO_S, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2300.         }
  2301.         }
  2302.     }
  2303.     }
  2304.  
  2305.   /* Binary operations without carry-in.  */
  2306.   for (s1 = n_values - 1; s1 >= 0; s1--)
  2307.     {
  2308.       r1 = values[s1];
  2309.       for (s2 = s1 - 1; s2 >= 0; s2--)
  2310.     {
  2311.       r2 = values[s2];
  2312.       for (dr = n_values; dr >= 0; dr--)
  2313.         {
  2314.           /* hppa:    add */
  2315.           if (!nullify_flag_in) PERFORM_ADD_CO_S(v, co, nullify_flag, r1, r2, ci);
  2316.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2317.           PA_RECURSE(ADD_CO_S, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2318.  
  2319.           /* hppa:    addl */
  2320.           if (!nullify_flag_in) PERFORM_ADD_S(v, co, nullify_flag, r1, r2, ci);
  2321.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2322.           PA_RECURSE(ADD_S, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2323.  
  2324.           /* hppa:    sub */
  2325.           if (!nullify_flag_in) PERFORM_ADC_CO_S(v, co, nullify_flag, r1, r2, ci);
  2326.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2327.           PA_RECURSE(ADC_CO_S, dr, s1, s2, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2328.           if (!nullify_flag_in) PERFORM_ADC_CO_S(v, co, nullify_flag, r2, r1, ci);
  2329.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2330.           PA_RECURSE(ADC_CO_S, dr, s2, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2331.  
  2332.           /* hppa:    and */
  2333.           if (!nullify_flag_in) PERFORM_AND_S(v, co, nullify_flag, r1, r2, ci);
  2334.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2335.           PA_RECURSE(AND_S, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2336.  
  2337.           /* hppa:    or */
  2338.           if (!nullify_flag_in) PERFORM_IOR_S(v, co, nullify_flag, r1, r2, ci);
  2339.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2340.           PA_RECURSE(IOR_S, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2341.  
  2342.           /* hppa:    xor */
  2343.           if (!nullify_flag_in) PERFORM_XOR_S(v, co, nullify_flag, r1, r2, ci);
  2344.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2345.           PA_RECURSE(XOR_S, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2346.  
  2347.           /* hppa:    andcm */
  2348.           if (!nullify_flag_in) PERFORM_ANDC_S(v, co, nullify_flag, r1, r2, ci);
  2349.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2350.           PA_RECURSE(ANDC_S, dr, s1, s2, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2351.  
  2352.           if (!nullify_flag_in) PERFORM_ANDC_S(v, co, nullify_flag, r2, r1, ci);
  2353.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2354.           PA_RECURSE(ANDC_S, dr, s2, s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2355.         }
  2356.     }
  2357.     }
  2358.  
  2359.   /* Unary operations with carry-in.  */
  2360.   if (ci >= 0 && flag_use_carry)
  2361.     {
  2362.       for (s1 = n_values - 1; s1 >= 0; s1--)
  2363.     {
  2364.       r1 = values[s1];
  2365.       for (dr = n_values; dr >= 0; dr--)
  2366.         {
  2367.           /* d,cy = 2*r1 + cy
  2368.          hppa:    addc    s1,s1,d */
  2369.           if (!nullify_flag_in) PERFORM_ADD_CIO_S(v, co, nullify_flag, r1, r1, ci);
  2370.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2371.           PA_RECURSE(ADD_CIO_S, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2372.  
  2373.           /* d,cy = r1 + cy - 1
  2374.          hppa:    subb    s1,r0,d */
  2375.           if (!nullify_flag_in) PERFORM_ADD_CIO_S(v, co, nullify_flag, r1, VALUE(-1), ci);
  2376.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2377.           PA_RECURSE(ADD_CIO_S, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2378.  
  2379.           /* d,cy = r1 + cy
  2380.          hppa:    addc    s1,r0,d */
  2381.           if (!nullify_flag_in) PERFORM_ADD_CIO_S(v, co, nullify_flag, r1, VALUE(0), ci);
  2382.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2383.           PA_RECURSE(ADD_CIO_S, dr, s1, CNST(0), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2384.  
  2385.           /* d,cy = ~r1 + cy
  2386.          hppa:    subb    r0,s1,d */
  2387.           if (!nullify_flag_in) PERFORM_ADC_CIO_S(v, co, nullify_flag, VALUE(0), r1, ci);
  2388.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2389.           PA_RECURSE(ADC_CIO_S, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2390.         }
  2391.     }
  2392.     }
  2393.  
  2394.   /* Unary operations without carry-in.  */
  2395.   for (s1 = n_values - 1; s1 >= 0; s1--)
  2396.     {
  2397.       r1 = values[s1];
  2398.       for (dr = n_values; dr >= 0; dr--)
  2399.     {
  2400.       /* d,cy = 2*r1
  2401.          hppa:        add    s1,s1,d */
  2402.       if (!nullify_flag_in) PERFORM_ADD_CO_S(v, co, nullify_flag, r1, r1, ci);
  2403.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2404.       PA_RECURSE(ADD_CO_S, dr, s1, s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2405.  
  2406.       /* d = r1 & 1
  2407.          hppa:        extru    s1,31,1,d */
  2408.       if (!nullify_flag_in) PERFORM_AND_S(v, co, nullify_flag, r1, VALUE(1), ci);
  2409.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2410.       PA_RECURSE(AND_S, dr, s1, CNST(1), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2411.  
  2412.       /* d = r1 & 0x7fffffff
  2413.          hppa:        extru    s1,31,31,d */
  2414.       if (!nullify_flag_in) PERFORM_AND_S(v, co, nullify_flag, r1, VALUE_MAX_SIGNED, ci);
  2415.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2416.       PA_RECURSE(AND_S, dr, s1, CNST_0x7FFFFFFF, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2417.  
  2418.       /* d = ~r1
  2419.          hppa:        andcm    r0,s1,d */
  2420.       if (!nullify_flag_in) PERFORM_SUB_S(v, co, nullify_flag, VALUE(-1), r1, ci);
  2421.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2422.       PA_RECURSE(SUB_S, dr, CNST(-1), s1, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2423.  
  2424.       /* d,cy = -1 + ~r1 + 1 (i.e. one's complement and set carry.)
  2425.          hppa:    subi    -1,s1,d */
  2426.       if (!nullify_flag_in) PERFORM_ADC_CO_S(v, co, nullify_flag, VALUE(-1), r1, ci);
  2427.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2428.       PA_RECURSE(ADC_CO_S, dr, CNST(-1), s1, CY_JUST_SET | CY_1 | NULLIFYING_INSN, nullify_flag);
  2429.  
  2430.       /* d,cy = r1 + 1
  2431.          hppa:        addi    1,s1,d */
  2432.       if (!nullify_flag_in) PERFORM_ADD_CO_S(v, co, nullify_flag, r1, VALUE(1), ci);
  2433.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2434.       PA_RECURSE(ADD_CO_S, dr, s1, CNST(1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2435.  
  2436.       /* d,cy = r1 + -1
  2437.          hppa:        addi    -1,s1,d */
  2438.       if (!nullify_flag_in) PERFORM_ADD_CO_S(v, co, nullify_flag, r1, VALUE(-1), ci);
  2439.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2440.       PA_RECURSE(ADD_CO_S, dr, s1, CNST(-1), CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2441.  
  2442.       /* d,cy = -r1
  2443.          hppa:        subi    0,s1,d */
  2444.       if (!nullify_flag_in) PERFORM_ADC_CO_S(v, co, nullify_flag, VALUE(0), r1, ci);
  2445.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2446.       PA_RECURSE(ADC_CO_S, dr, CNST(0), s1, CY_JUST_SET | NULLIFYING_INSN, nullify_flag);
  2447.  
  2448.       {
  2449.         int cnt;
  2450.         for (cnt = 1; cnt < BITS_PER_WORD; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 2))
  2451.           {
  2452.         if (!nullify_flag_in) PERFORM_LSHIFTR_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2453.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2454.         PA_RECURSE(LSHIFTR_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2455.  
  2456.         if (!nullify_flag_in) PERFORM_ASHIFTR_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2457.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2458.         PA_RECURSE(ASHIFTR_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2459.  
  2460.         if (!nullify_flag_in) PERFORM_SHIFTL_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2461.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2462.         PA_RECURSE(SHIFTL_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2463.  
  2464.         if (!nullify_flag_in) PERFORM_ROTATEL_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2465.         else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2466.         PA_RECURSE(ROTATEL_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2467.           }
  2468.       }
  2469.  
  2470.       if (flag_extracts)
  2471.         {
  2472.           int cnt;
  2473.           /* Loop to 30, not 31, since 31 would generate operations
  2474.          identical to shifts by 31.  */
  2475.           for (cnt = 1; cnt < BITS_PER_WORD - 1; cnt++)
  2476.         {
  2477.           if (!nullify_flag_in) PERFORM_EXTS1_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2478.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2479.           PA_RECURSE(EXTS1_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2480.           if (!nullify_flag_in) PERFORM_EXTU1_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2481.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2482.           PA_RECURSE(EXTU1_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2483.         }
  2484.           /* Loop to 29, not 31, since 30 and 31 would generate operations
  2485.          identical to shifts by 30 and 31.  */
  2486.           for (cnt = 1; cnt < BITS_PER_WORD - 2; cnt++)
  2487.         {
  2488.           if (!nullify_flag_in) PERFORM_EXTS2_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2489.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2490.           PA_RECURSE(EXTS2_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2491.           if (!nullify_flag_in) PERFORM_EXTU2_S(v, co, nullify_flag, r1, VALUE(cnt), ci);
  2492.           else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2493.           PA_RECURSE(EXTU2_S, dr, s1, CNST(cnt), (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2494.         }
  2495.         }
  2496.  
  2497.       /* Copy register->register since we might be nullified.  */
  2498.       if (!nullify_flag_in) PERFORM_COPY_S(v, co, nullify_flag, r1, ci);
  2499.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2500.       PA_RECURSE(COPY_S, dr, s1, 0, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2501.     }
  2502.     }
  2503.  
  2504.   /* 0-ary instructions, just dependent on carry.  */
  2505.   if (ci >= 0 && flag_use_carry)
  2506.     {
  2507.       for (dr = n_values; dr >= 0; dr--)
  2508.     {
  2509.       /* We don't do "0 - 1 - cy" or "0 + 1 + cy" here.  It would
  2510.          probably give very few new sequences. */
  2511.       /* d = cy, cy = 0.
  2512.          hppa:        addc    r0,r0,d */
  2513.       if (!nullify_flag_in) PERFORM_ADD_CIO_S(v, co, nullify_flag, VALUE(0), VALUE(0), ci);
  2514.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2515.       PA_RECURSE(ADD_CIO_S, dr, CNST(0), CNST(0), CY_JUST_SET | CY_0 | NULLIFYING_INSN, nullify_flag);
  2516.       /* d = -1 + cy, cy = cy
  2517.          hppa:        subb    d,d,d */
  2518.       if (!nullify_flag_in) PERFORM_ADC_CIO_S(v, co, nullify_flag, VALUE(0), VALUE(0), ci);
  2519.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2520.       PA_RECURSE(ADC_CIO_S, dr, n_values, n_values, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2521.     }
  2522.     }
  2523.  
  2524.   for (dr = n_values; dr >= 0; dr--)
  2525.     {
  2526.       /* Move instructions.  */
  2527.       /* d = 0x80000000
  2528.      hppa:        zdepi,tr    1,0,1,d */
  2529.       if (!nullify_flag_in) PERFORM_COPY_S(v, co, nullify_flag, VALUE_MIN_SIGNED, ci);
  2530.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2531.       PA_RECURSE(COPY_S, dr, CNST_0x80000000, 0, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2532.       /* d = -1
  2533.      hppa:        addi,tr        -1,r0,d */
  2534.       if (!nullify_flag_in) PERFORM_COPY_S(v, co, nullify_flag, VALUE(-1), ci);
  2535.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2536.       PA_RECURSE(COPY_S, dr, CNST(-1), 0, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2537.       /* d = 1
  2538.      hppa:        addi,tr        1,r0,d */
  2539.       if (!nullify_flag_in) PERFORM_COPY_S(v, co, nullify_flag, VALUE(1), ci);
  2540.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2541.       PA_RECURSE(COPY_S, dr, CNST(1), 0, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2542.       /* d = 0
  2543.      hppa:        addi,tr        0,r0,d */
  2544.       if (!nullify_flag_in) PERFORM_COPY_S(v, co, nullify_flag, VALUE(0), ci);
  2545.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2546.       PA_RECURSE(COPY_S, dr, CNST(0), 0, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2547.       /* d = 0x7fffffff
  2548.      hppa:        zdepi,tr    -1,31,31,d */
  2549.       if (!nullify_flag_in) PERFORM_COPY_S(v, co, nullify_flag, VALUE_MAX_SIGNED, ci);
  2550.       else PERFORM_NULLIFIED(v, co, nullify_flag, ci);
  2551.       PA_RECURSE(COPY_S, dr, CNST_0x7FFFFFFF, 0, (prune_hint & ~CY_JUST_SET) | NULLIFYING_INSN, nullify_flag);
  2552.     }
  2553. }
  2554. #endif /* !MAKE_LEAF */
  2555. #endif /* HPPA */
  2556.  
  2557. #if M68000 || I386 || PYR || SH
  2558. void
  2559. MAKENAME (synth) (insn_t *sequence,
  2560.           int n_insns,
  2561.           word *values,
  2562.           int n_values,
  2563.           word goal_value,
  2564.           int allowed_cost,
  2565.           int ci,
  2566.           int prune_hint)
  2567. {
  2568.   int s1, s2;
  2569.   word v, r1, r2;
  2570.   int co;
  2571.   int last_dest;
  2572.  
  2573. #ifdef TIMING
  2574.   unsigned long time_start = cputime();
  2575. #endif
  2576.  
  2577.   if (n_insns > 0)
  2578.     last_dest = sequence[n_insns - 1].d;
  2579.   else
  2580.     last_dest = -1;
  2581.  
  2582.   /* Binary operations with carry-in.  */
  2583.   if (ci >= 0
  2584. #if !SH /* We have to clear carry for addc, subc, and negc */
  2585.       && (prune_hint & CY_0) == 0
  2586. #endif
  2587.       && flag_use_carry)
  2588.     {
  2589.       for (s1 = n_values - 1; s1 >= 0; s1--)
  2590.     {
  2591.       r1 = values[s1];
  2592.       for (s2 = n_values - 1; s2 >= 0; s2--)
  2593.         {
  2594.           r2 = values[s2];
  2595.  
  2596.           if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  2597.         {
  2598.           /* We are in a leaf node.  CY was not set (to 1 or to a
  2599.              data dependent value) by the previous insn.
  2600.  
  2601.              So one of the input operands has to be the result
  2602.              operand of the previous insn for that insn to be
  2603.              meaningful.  */
  2604.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  2605.             continue;
  2606.         }
  2607.  
  2608. #if M68000 || I386 || PYR || SH
  2609.           /* m68000:    addx
  2610.          i80386:    adc
  2611.          pyramid:    addwc
  2612.          sh:        addc */
  2613.           PERFORM_ADD_CIO(v, co, r1, r2, ci);
  2614.           CRECURSE_2OP(ADD_CIO, s1, s1, s2, 1, CY_JUST_SET);
  2615. #endif
  2616. #if M68000 || I386 || SH
  2617.           if (s1 != s2)
  2618.         {
  2619.           /* m68000:    subx
  2620.              i80386:    sbb
  2621.              sh:    subc */
  2622.           PERFORM_SUB_CIO(v, co, r1, r2, ci);
  2623.           CRECURSE_2OP(SUB_CIO, s1, s1, s2, 1, CY_JUST_SET);
  2624.         }
  2625. #endif
  2626. #if PYR
  2627.           if (s1 != s2)
  2628.         {
  2629.           /* pyramid:    subwb */
  2630.           PERFORM_ADC_CIO(v, co, r1, r2, ci);
  2631.           CRECURSE_2OP(ADC_CIO, s1, s1, s2, 1, CY_JUST_SET);
  2632.         }
  2633. #endif
  2634.         }
  2635.     }
  2636.     }
  2637.  
  2638.   /* Binary operations without carry-in.  */
  2639.   for (s1 = n_values - 1; s1 >= 0; s1--)
  2640.     {
  2641.       r1 = values[s1];
  2642.       for (s2 = n_values - 1; s2 >= 0; s2--)
  2643.     {
  2644.       r2 = values[s2];
  2645.  
  2646.       if (allowed_cost <= 1)
  2647.         {
  2648.           /* We are in a leaf node.
  2649.  
  2650.          So one of the input operands has to be the result operand
  2651.          of the previous insn for that insn to be meaningful.  */
  2652.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  2653.         continue;
  2654.         }
  2655.  
  2656. #if SH
  2657.       /* sh:    add */
  2658.       PERFORM_ADD(v, co, r1, r2, ci);
  2659.       CRECURSE_2OP(ADD, s1, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  2660. #endif
  2661. #if M68000 || I386 || PYR
  2662.       /* m68000:    add
  2663.          i80386:    add
  2664.          pyramid:    addw */
  2665.       PERFORM_ADD_CO(v, co, r1, r2, ci);
  2666.       CRECURSE_2OP(ADD_CO, s1, s1, s2, 1, CY_JUST_SET);
  2667. #endif
  2668.       if (s1 != s2)
  2669.         {
  2670. #if SH
  2671.       /* sh:    sub */
  2672.       PERFORM_SUB(v, co, r1, r2, ci);
  2673.       CRECURSE_2OP(SUB, s1, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  2674. #endif
  2675. #if M68000 || I386
  2676.           /* m68000:    sub
  2677.          i80386:    sub */
  2678.           PERFORM_SUB_CO(v, co, r1, r2, ci);
  2679.           CRECURSE_2OP(SUB_CO, s1, s1, s2, 1, CY_JUST_SET);
  2680. #endif
  2681. #if PYR
  2682.           /* pyramid:    subw */
  2683.           PERFORM_ADC_CO(v, co, r1, r2, ci);
  2684.           CRECURSE_2OP(ADC_CO, s1, s1, s2, 1, CY_JUST_SET);
  2685. #endif
  2686. #if M68000 || SH
  2687.           PERFORM_AND(v, co, r1, r2, ci);
  2688.           CRECURSE_2OP(AND, s1, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  2689.  
  2690.           PERFORM_IOR(v, co, r1, r2, ci);
  2691.           CRECURSE_2OP(IOR, s1, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  2692.  
  2693.           PERFORM_XOR(v, co, r1, r2, ci);
  2694.           CRECURSE_2OP(XOR, s1, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  2695. #endif
  2696. #if I386
  2697.           PERFORM_AND_RC(v, co, r1, r2, ci);
  2698.           CRECURSE_2OP(AND_RC, s1, s1, s2, 1, CY_JUST_SET | CY_0);
  2699.  
  2700.           PERFORM_IOR_RC(v, co, r1, r2, ci);
  2701.           CRECURSE_2OP(IOR_RC, s1, s1, s2, 1, CY_JUST_SET | CY_0);
  2702.  
  2703.           PERFORM_XOR_RC(v, co, r1, r2, ci);
  2704.           CRECURSE_2OP(XOR_RC, s1, s1, s2, 1, CY_JUST_SET | CY_0);
  2705. #endif
  2706. #if PYR
  2707.           PERFORM_AND_CC(v, co, r1, r2, ci);
  2708.           CRECURSE_2OP(AND_CC, s1, s1, s2, 1, 0);
  2709.  
  2710.           PERFORM_ANDC_CC(v, co, r1, r2, ci);
  2711.           CRECURSE_2OP(ANDC_CC, s1, s1, s2, 1, 0);
  2712.  
  2713.           PERFORM_IOR_CC(v, co, r1, r2, ci);
  2714.           CRECURSE_2OP(IOR_CC, s1, s1, s2, 1, 0);
  2715.  
  2716.           PERFORM_XOR_CC(v, co, r1, r2, ci);
  2717.           CRECURSE_2OP(XOR_CC, s1, s1, s2, 1, 0);
  2718. #endif
  2719. #if I386
  2720.           PERFORM_CMP(v, co, r1, r2, ci);
  2721.           /* kludge: lie that the result is written to
  2722.          register <n_values>. */
  2723.           CRECURSE_2OP(CMP, n_values, s1, s2, 1, CY_JUST_SET);
  2724. #endif
  2725. #if SH
  2726.           /* kludge: lie that the result is written to
  2727.          register <n_values>. */
  2728.           PERFORM_CYGTU(v, co, r1, r2, ci);
  2729.           CRECURSE_2OP(CYGTU, n_values, s1, s2, 1, CY_JUST_SET);
  2730.           PERFORM_CYGEU(v, co, r1, r2, ci);
  2731.           CRECURSE_2OP(CYGEU, n_values, s1, s2, 1, CY_JUST_SET);
  2732.           PERFORM_CYGTS(v, co, r1, r2, ci);
  2733.           CRECURSE_2OP(CYGTS, n_values, s1, s2, 1, CY_JUST_SET);
  2734.           PERFORM_CYGES(v, co, r1, r2, ci);
  2735.           CRECURSE_2OP(CYGES, n_values, s1, s2, 1, CY_JUST_SET);
  2736.           /* These are commutative, we don't want to try both variants.  */
  2737.           if (s1 < s2)
  2738.         {
  2739.           PERFORM_CYEQ(v, co, r1, r2, ci);
  2740.           CRECURSE_2OP(CYEQ, n_values, s1, s2, 1, CY_JUST_SET);
  2741.  
  2742.           /* sh:    tst    s2,s1 */
  2743.           PERFORM_CYAND(v, co, r1, r2, ci);
  2744.           CRECURSE_2OP(CYAND, n_values, s1, s2, 1, CY_JUST_SET);
  2745.         }
  2746.  
  2747.           PERFORM_MERGE16(v, co, r1, r2, ci);
  2748.           CRECURSE_2OP(MERGE16, s1, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  2749. #endif
  2750.         }
  2751. #if M68000 || I386 || PYR
  2752.       /* Exchange registers.  An ugly kludge.  */
  2753.       if (s1 < s2)
  2754.         {
  2755.           values[s2] = r1;
  2756.           /* Assign r2 to v to make `recurse' and rely on `recurse'
  2757.          to handle the writing of it to the values array.  */
  2758.           v = r2;
  2759.           CRECURSE_2OP(EXCHANGE, s1, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  2760.           values[s2] = r2;
  2761.         }
  2762. #endif
  2763.     }
  2764.     }
  2765.  
  2766.   /* Unary operations with carry-in.  */
  2767.   if (ci >= 0
  2768. #if !SH /* We have to clear carry for addc, subc, and negc */
  2769.       && (prune_hint & CY_0) == 0
  2770. #endif
  2771.       && flag_use_carry)
  2772.     {
  2773.       for (s1 = n_values - 1; s1 >= 0; s1--)
  2774.     {
  2775.       r1 = values[s1];
  2776.  
  2777.       if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  2778.         {
  2779.           /* We are in a leaf node and CY was not set (to 1 or to a
  2780.          data dependent value) by the previous insn.
  2781.  
  2782.          The input operand has to be the result operand of the
  2783.          previous insn for that insn to be meaningful.  */
  2784.           if (last_dest >= 0 && s1 != last_dest)
  2785.         continue;
  2786.         }
  2787.  
  2788. #if I386 || PYR
  2789.       /* d,cy = r1 + 1 + cy
  2790.          i80386:    adc    1,d
  2791.          pyramid:    addwc    $1,d */
  2792.       PERFORM_ADD_CIO(v, co, r1, VALUE(1), ci);
  2793.       CRECURSE_2OP(ADD_CIO, s1, s1, CNST(1), 1, CY_JUST_SET);
  2794. #endif
  2795. #if I386
  2796.       /* d,cy = r1 - 1 - cy
  2797.          i80386:    sbb    1,d */
  2798.       PERFORM_SUB_CIO(v, co, r1, VALUE(1), ci);
  2799.       CRECURSE_2OP(SUB_CIO, s1, s1, CNST(1), 1, CY_JUST_SET);
  2800. #endif
  2801. #if PYR
  2802.       /* d,cy = r1 + (-2) + cy
  2803.          pyramid:    subwb    $1,d */
  2804.       PERFORM_ADC_CIO(v, co, r1, VALUE(1), ci);
  2805.       CRECURSE_2OP(ADC_CIO, s1, s1, CNST(1), 1, CY_JUST_SET);
  2806. #endif
  2807. #if I386 || PYR
  2808.       /* d,cy = r1 + (-1) + cy
  2809.          i80386:    adc    -1,d
  2810.          pyramid:    addwc    $-1,d */
  2811.       PERFORM_ADD_CIO(v, co, r1, VALUE(-1), ci);
  2812.       CRECURSE_2OP(ADD_CIO, s1, s1, CNST(-1), 1, CY_JUST_SET);
  2813. #endif
  2814. #if I386
  2815.       /* d,cy = r1 - -1 - cy
  2816.          i80386:    sbb    -1,d */
  2817.       PERFORM_SUB_CIO(v, co, r1, VALUE(-1), ci);
  2818.       CRECURSE_2OP(SUB_CIO, s1, s1, CNST(-1), 1, CY_JUST_SET);
  2819. #endif
  2820. #if PYR
  2821.       /* d,cy = r1 + cy    [or if you prefer, r1 + 0 + cy]
  2822.          pyramid:    subwb    $-1,d */
  2823.       PERFORM_ADC_CIO(v, co, r1, VALUE(-1), ci);
  2824.       CRECURSE_2OP(ADC_CIO, s1, s1, CNST(-1), 1, CY_JUST_SET);
  2825. #endif
  2826. #if I386 || PYR
  2827.       /* d,cy = r1 + cy
  2828.          i80386:    adc    0,d
  2829.          pyramid:    addwc    $0,d */
  2830.       PERFORM_ADD_CIO(v, co, r1, VALUE(0), ci);
  2831.       CRECURSE_2OP(ADD_CIO, s1, s1, CNST(0), 1, CY_JUST_SET);
  2832. #endif
  2833. #if I386
  2834.       /* d,cy = r1 - cy
  2835.          i80386:    sbb    0,d */
  2836.       PERFORM_SUB_CIO(v, co, r1, VALUE(0), ci);
  2837.       CRECURSE_2OP(SUB_CIO, s1, s1, CNST(0), 1, CY_JUST_SET);
  2838. #endif
  2839. #if PYR
  2840.       /* d,cy = r1 + (-1) + cy
  2841.          pyramid:    subwb    $0,d */
  2842.       PERFORM_ADC_CIO(v, co, r1, VALUE(0), ci);
  2843.       CRECURSE_2OP(ADC_CIO, s1, s1, CNST(0), 1, CY_JUST_SET);
  2844. #endif
  2845. #if M68000
  2846.       /* d,cy = 0 - r1 - cy
  2847.          m68000:    negx    d */
  2848.       PERFORM_SUB_CIO(v, co, VALUE(0), r1, ci);
  2849.       CRECURSE_2OP(SUB_CIO, s1, CNST(0), s1, 1, CY_JUST_SET);
  2850. #endif
  2851. #if SH
  2852.       /* d,cy = 0 - r1 - cy
  2853.          sh:    negc    s1,d */
  2854.       PERFORM_SUB_CIO(v, co, VALUE(0), r1, ci);
  2855.       CRECURSE_NEW(SUB_CIO, n_values, CNST(0), s1, 1, CY_JUST_SET);
  2856. #endif
  2857. #if (M68000 || I386 || SH) && 0        /* same effect as ADD_CIO d,d */
  2858.       PERFORM_ROTATEXL_CIO(v, co, r1, VALUE(1), ci);
  2859.       CRECURSE_2OP(ROTATEXL_CIO, s1, s1, CNST(1), SHIFT_COST(1), CY_JUST_SET);
  2860. #endif
  2861. #if M68000 || I386 || SH
  2862.       PERFORM_ROTATEXR_CIO(v, co, r1, VALUE(1), ci);
  2863.       CRECURSE_2OP(ROTATEXR_CIO, s1, s1, CNST(1), SHIFT_COST(1), CY_JUST_SET);
  2864. #endif
  2865.     }
  2866.     }
  2867.  
  2868.   /* Unary operations without carry-in.  */
  2869.   for (s1 = n_values - 1; s1 >= 0; s1--)
  2870.     {
  2871.       r1 = values[s1];
  2872.  
  2873.       if (allowed_cost <= 1)
  2874.     {
  2875.       /* We are in a leaf node.
  2876.  
  2877.          The input operand has to be the result operand of the
  2878.          previous insns for that insn to be meaningful.  */
  2879.       if (last_dest >= 0 && s1 != last_dest)
  2880.         continue;
  2881.     }
  2882.       else
  2883.     {
  2884.       /* Certain instructions should not terminate a sequence.  So we
  2885.          only generate them in non-leaf nodes.  */
  2886. #if M68000 || I386 || PYR || SH
  2887.       /* d = r1
  2888.          m68000:    move    s1,d
  2889.          i80386:    move    s1,d
  2890.          pyramid:    movw    s1,d
  2891.          sh:    mov    s1,d */
  2892.       PERFORM_COPY(v, co, r1, ci);
  2893.       CRECURSE_NEW(COPY, n_values, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  2894. #endif
  2895. #if I386
  2896.       /* cmp kludge: lie that the result is written to register
  2897.          <n_values>. */
  2898.  
  2899.       /* i80386:    cmp    -1,s1 */
  2900.       PERFORM_CMP(v, co, r1, VALUE(-1), ci);
  2901.       CRECURSE_2OP(CMP, n_values, s1, CNST(-1), 1, CY_JUST_SET);
  2902.  
  2903.       /* i80386:    cmp    1,s1 */
  2904.       PERFORM_CMP(v, co, r1, VALUE(1), ci);
  2905.       CRECURSE_2OP(CMP, n_values, s1, CNST(1), 1, CY_JUST_SET);
  2906.  
  2907.       /* i80386:    cmp    0x7fffffff,s1 */
  2908.       PERFORM_CMP(v, co, r1, VALUE_MAX_SIGNED, ci);
  2909.       CRECURSE_2OP(CMP, n_values, s1, CNST_0x7FFFFFFF, 2, CY_JUST_SET);
  2910.  
  2911.       /* i80386:    cmp    0x80000000,s1 */
  2912.       PERFORM_CMP(v, co, r1, VALUE_MIN_SIGNED, ci);
  2913.       CRECURSE_2OP(CMP, n_values, s1, CNST_0x80000000, 2, CY_JUST_SET);
  2914. #endif
  2915. #if SH
  2916.       /* kludge: lie that the result is written to register <n_values>. */
  2917.       PERFORM_CYGTS(v, co, r1, VALUE(0), ci);
  2918.       CRECURSE_2OP(CYGTS, n_values, s1, CNST(0), 1, CY_JUST_SET);
  2919.       PERFORM_CYGES(v, co, r1, VALUE(0), ci);
  2920.       CRECURSE_2OP(CYGES, n_values, s1, CNST(0), 1, CY_JUST_SET);
  2921.       PERFORM_CYEQ(v, co, r1, VALUE(0), ci);
  2922.       CRECURSE_2OP(CYEQ, n_values, s1, CNST(0), 1, CY_JUST_SET);
  2923. #endif
  2924.     }
  2925.  
  2926. #if I386 || PYR
  2927.       {
  2928.     int cnt;
  2929.     for (cnt = 1; cnt < BITS_PER_WORD; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 2))
  2930.       {
  2931.         PERFORM_LSHIFTR_CO(v, co, r1, VALUE(cnt), ci);
  2932.         CRECURSE_2OP(LSHIFTR_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2933.  
  2934.         PERFORM_ASHIFTR_CO(v, co, r1, VALUE(cnt), ci);
  2935.         CRECURSE_2OP(ASHIFTR_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2936.  
  2937.         PERFORM_SHIFTL_CO(v, co, r1, VALUE(cnt), ci);
  2938.         CRECURSE_2OP(SHIFTL_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2939.  
  2940. #if !PYR   /* Pyramids's rotlw and rotrw clobber cy */
  2941.         PERFORM_ROTATER_CO(v, co, r1, VALUE(cnt), ci);
  2942.         CRECURSE_2OP(ROTATER_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2943.  
  2944.         PERFORM_ROTATEL_CO(v, co, r1, VALUE(cnt), ci);
  2945.         CRECURSE_2OP(ROTATEL_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2946. #endif
  2947.       }
  2948.       }
  2949. #endif
  2950. #if MC68020            /* don't do this for plain 68000 */
  2951.       {
  2952.     int cnt;
  2953.     for (cnt = 1; cnt <= 8; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 2))
  2954.       {
  2955.         PERFORM_LSHIFTR_CO(v, co, r1, VALUE(cnt), ci);
  2956.         CRECURSE_2OP(LSHIFTR_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2957.  
  2958.         PERFORM_ASHIFTR_CO(v, co, r1, VALUE(cnt), ci);
  2959.         CRECURSE_2OP(ASHIFTR_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2960.  
  2961.         PERFORM_SHIFTL_CO(v, co, r1, VALUE(cnt), ci);
  2962.         CRECURSE_2OP(SHIFTL_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2963.  
  2964.         PERFORM_ROTATER_CO(v, co, r1, VALUE(cnt), ci);
  2965.         CRECURSE_2OP(ROTATER_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2966.  
  2967.         PERFORM_ROTATEL_CO(v, co, r1, VALUE(cnt), ci);
  2968.         CRECURSE_2OP(ROTATEL_CO, s1, s1, CNST(cnt), SHIFT_COST(cnt), CY_JUST_SET);
  2969.       }
  2970.       }
  2971. #endif
  2972. #if (M68000 && !MC68020) || SH
  2973.       PERFORM_LSHIFTR_CO(v, co, r1, VALUE(1), ci);
  2974.       CRECURSE_2OP(LSHIFTR_CO, s1, s1, CNST(1), SHIFT_COST(1), CY_JUST_SET);
  2975.  
  2976.       PERFORM_ASHIFTR_CO(v, co, r1, VALUE(1), ci);
  2977.       CRECURSE_2OP(ASHIFTR_CO, s1, s1, CNST(1), SHIFT_COST(1), CY_JUST_SET);
  2978.  
  2979.       PERFORM_SHIFTL_CO(v, co, r1, VALUE(1), ci);
  2980.       CRECURSE_2OP(SHIFTL_CO, s1, s1, CNST(1), SHIFT_COST(1), CY_JUST_SET);
  2981.  
  2982.       PERFORM_ROTATEL_CO(v, co, r1, VALUE(1), ci);
  2983.       CRECURSE_2OP(ROTATEL_CO, s1, s1, CNST(1), SHIFT_COST(1), CY_JUST_SET);
  2984.  
  2985.       PERFORM_ROTATER_CO(v, co, r1, VALUE(1), ci);
  2986.       CRECURSE_2OP(ROTATER_CO, s1, s1, CNST(1), SHIFT_COST(1), CY_JUST_SET);
  2987. #endif
  2988. #if SH
  2989.       PERFORM_LSHIFTR(v, co, r1, VALUE(2), ci);
  2990.       CRECURSE_2OP(LSHIFTR, s1, s1, CNST(2), SHIFT_COST(2), prune_hint & ~CY_JUST_SET);
  2991.  
  2992.       PERFORM_SHIFTL(v, co, r1, VALUE(2), ci);
  2993.       CRECURSE_2OP(SHIFTL, s1, s1, CNST(2), SHIFT_COST(2), prune_hint & ~CY_JUST_SET);
  2994.  
  2995.       PERFORM_LSHIFTR(v, co, r1, VALUE(8), ci);
  2996.       CRECURSE_2OP(LSHIFTR, s1, s1, CNST(8), SHIFT_COST(8), prune_hint & ~CY_JUST_SET);
  2997.  
  2998.       PERFORM_SHIFTL(v, co, r1, VALUE(8), ci);
  2999.       CRECURSE_2OP(SHIFTL, s1, s1, CNST(8), SHIFT_COST(8), prune_hint & ~CY_JUST_SET);
  3000.  
  3001.       PERFORM_LSHIFTR(v, co, r1, VALUE(16), ci);
  3002.       CRECURSE_2OP(LSHIFTR, s1, s1, CNST(16), SHIFT_COST(16), prune_hint & ~CY_JUST_SET);
  3003.  
  3004.       PERFORM_SHIFTL(v, co, r1, VALUE(16), ci);
  3005.       CRECURSE_2OP(SHIFTL, s1, s1, CNST(16), SHIFT_COST(16), prune_hint & ~CY_JUST_SET);
  3006.       /* sh:    swap.w %s1,d */
  3007.       PERFORM_ROTATEL(v, co, r1, VALUE(16), ci);
  3008.       CRECURSE_NEW(ROTATEL, n_values, s1, CNST(16), SHIFT_COST(16), prune_hint & ~CY_JUST_SET);
  3009. #endif
  3010. #if M68000 || SH
  3011.       /* m68000:    andw    #1,d
  3012.          sh:        and    #1,d */
  3013.       PERFORM_AND(v, co, r1, VALUE(1), ci);
  3014.       CRECURSE_2OP(AND, s1, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3015. #endif
  3016. #if SH
  3017.       /* sh:        extu.w    s1,d */
  3018.       PERFORM_AND(v, co, r1, VALUE(0xFFFF), ci);
  3019.       CRECURSE_NEW(AND, n_values, s1, CNST_0xFFFF, 1, prune_hint & ~CY_JUST_SET);
  3020.       /* sh:        extu.b    s1,d */
  3021.       PERFORM_AND(v, co, r1, VALUE(0xFF), ci);
  3022.       CRECURSE_NEW(AND, n_values, s1, CNST_0xFF, 1, prune_hint & ~CY_JUST_SET);
  3023.       /* sh:        exts.w    s1,d */
  3024.       PERFORM_EXTS16(v, co, r1, VALUE(0), ci);
  3025.       CRECURSE_NEW(EXTS16, n_values, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3026.       /* sh:        exts.b    s1,d */
  3027.       PERFORM_EXTS8(v, co, r1, VALUE(0), ci);
  3028.       CRECURSE_NEW(EXTS8, n_values, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3029. #endif
  3030. #if M68000
  3031.       PERFORM_AND(v, co, r1, VALUE_MIN_SIGNED, ci);
  3032.       CRECURSE_2OP(AND, s1, s1, CNST_0x80000000, 2, prune_hint & ~CY_JUST_SET);
  3033.  
  3034.       PERFORM_IOR(v, co, r1, VALUE_MIN_SIGNED, ci);
  3035.       CRECURSE_2OP(IOR, s1, s1, CNST_0x80000000, 2, prune_hint & ~CY_JUST_SET);
  3036. #endif
  3037. #if M68000 || SH
  3038.       /* d = r1 ^ 1
  3039.      m68000:    eorw    #1,d
  3040.      sh:        xor    #1,d */
  3041.       PERFORM_XOR(v, co, r1, VALUE(1), ci);
  3042.       CRECURSE_2OP(XOR, s1, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3043. #endif
  3044. #if M68000
  3045.       PERFORM_XOR(v, co, r1, VALUE_MIN_SIGNED, ci);
  3046.       CRECURSE_2OP(XOR, s1, s1, CNST_0x80000000, 2, prune_hint & ~CY_JUST_SET);
  3047. #endif
  3048. #if I386
  3049.       /* i80386:    andb    $1,d */
  3050.       PERFORM_AND_RC(v, co, r1, VALUE(1), ci);
  3051.       CRECURSE_2OP(AND_RC, s1, s1, CNST(1), 1, CY_JUST_SET | CY_0);
  3052.  
  3053.       PERFORM_AND_RC(v, co, r1, VALUE_MIN_SIGNED, ci);
  3054.       CRECURSE_2OP(AND_RC, s1, s1, CNST_0x80000000, 2, CY_JUST_SET | CY_0);
  3055.  
  3056.       PERFORM_IOR_RC(v, co, r1, VALUE_MIN_SIGNED, ci);
  3057.       CRECURSE_2OP(IOR_RC, s1, s1, CNST_0x80000000, 2, CY_JUST_SET | CY_0);
  3058.       /* i80386:    xorb    $1,d */
  3059.       PERFORM_XOR_RC(v, co, r1, VALUE(1), ci);
  3060.       CRECURSE_2OP(XOR_RC, s1, s1, CNST(1), 1, CY_JUST_SET | CY_0);
  3061.  
  3062.       PERFORM_XOR_RC(v, co, r1, VALUE_MIN_SIGNED, ci);
  3063.       CRECURSE_2OP(XOR_RC, s1, s1, CNST_0x80000000, 2, CY_JUST_SET | CY_0);
  3064. #endif
  3065. #if PYR
  3066.       PERFORM_AND_CC(v, co, r1, VALUE(1), ci);
  3067.       CRECURSE_2OP(AND_CC, s1, s1, CNST(1), 1, 0);
  3068.  
  3069.       PERFORM_AND_CC(v, co, r1, VALUE_MIN_SIGNED, ci);
  3070.       CRECURSE_2OP(AND_CC, s1, s1, CNST_0x80000000, 2, 0);
  3071.  
  3072.       PERFORM_IOR_CC(v, co, r1, VALUE_MIN_SIGNED, ci);
  3073.       CRECURSE_2OP(IOR_CC, s1, s1, CNST_0x80000000, 2, 0);
  3074.  
  3075.       /* d = r1 ^ 1
  3076.      pyramid:    xorw    $1,d */
  3077.       PERFORM_XOR_CC(v, co, r1, VALUE(1), ci);
  3078.       CRECURSE_2OP(XOR_CC, s1, s1, CNST(1), 1, 0);
  3079.  
  3080.       PERFORM_XOR_CC(v, co, r1, VALUE_MIN_SIGNED, ci);
  3081.       CRECURSE_2OP(XOR_CC, s1, s1, CNST_0x80000000, 2, 0);
  3082. #endif
  3083. #if M68000 || I386
  3084.       /* d = ~r1
  3085.      m68000:    not    d
  3086.      i80386:    not    d */
  3087.       PERFORM_SUB(v, co, VALUE(-1), r1, ci);
  3088.       CRECURSE_2OP(SUB, s1, CNST(-1), s1, 1, prune_hint & ~CY_JUST_SET);
  3089. #endif
  3090. #if SH
  3091.       /* d = ~r1
  3092.      sh:        not    s1,d */
  3093.       PERFORM_SUB(v, co, VALUE(-1), r1, ci);
  3094.       CRECURSE_NEW(SUB, n_values, CNST(-1), s1, 1, prune_hint & ~CY_JUST_SET);
  3095. #endif
  3096. #if PYR
  3097.       /* d = ~r1
  3098.      pyramid:    mcomw    s1,d */
  3099.       /* We need a new insn: SUB_CC, for Subtract and Clobber Carry.  */
  3100. #endif
  3101. #if I386 || SH
  3102.       /* d = r1 + 1
  3103.      i80386:    inc    d
  3104.      sh:        add    #1,d */
  3105.       PERFORM_ADD(v, co, r1, VALUE(1), ci);
  3106.       CRECURSE_2OP(ADD, s1, s1, CNST(1), 2, prune_hint & ~CY_JUST_SET);
  3107. #endif
  3108. #if PYR
  3109.       /* d = r1 + 1
  3110.      pyramid:    mova    1(s1),d */
  3111.       PERFORM_ADD(v, co, r1, VALUE(1), ci);
  3112.       RECURSE(ADD, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3113. #endif
  3114. #if I386 || SH
  3115.       /* d = r1 - 1
  3116.      i80386:    dec    d
  3117.      sh:        add    #-1,d */
  3118.       PERFORM_ADD(v, co, r1, VALUE(-1), ci);
  3119.       CRECURSE_2OP(ADD, s1, s1, CNST(-1), 1, prune_hint & ~CY_JUST_SET);
  3120. #endif
  3121. #if PYR
  3122.       /* d = r1 - 1
  3123.      pyramid:    mova    -1(s1),d */
  3124.       PERFORM_ADD(v, co, r1, VALUE(-1), ci);
  3125.       RECURSE(ADD, s1, CNST(-1), prune_hint & ~CY_JUST_SET);
  3126. #endif
  3127. #if M68000 || I386 || PYR
  3128.       /* d,cy = r1 + 1
  3129.      m68000:    addq    1,d
  3130.      i80386:    add    1,d [short immediate form]
  3131.      pyramid:    addw    $1,d */
  3132.       PERFORM_ADD_CO(v, co, r1, VALUE(1), ci);
  3133.       CRECURSE_2OP(ADD_CO, s1, s1, CNST(1), 1, CY_JUST_SET);
  3134. #endif
  3135. #if M68000 || I386
  3136.       /* d,cy = r1 - 1
  3137.      m68000:    subq    1,d
  3138.      i80386:    sub    1,d [short immediate form] */
  3139.       PERFORM_SUB_CO(v, co, r1, VALUE(1), ci);
  3140.       CRECURSE_2OP(SUB_CO, s1, s1, CNST(1), 1, CY_JUST_SET);
  3141. #endif
  3142. #if PYR && 0            /* same effect as addw $-1,d */
  3143.       /* d,cy = r1 + (-1)
  3144.      pyramid:    subw    1,d */
  3145.       PERFORM_ADC_CO(v, co, r1, VALUE(1), ci);
  3146.       CRECURSE_2OP(ADC_CO, s1, s1, CNST(1), 1, CY_JUST_SET);
  3147. #endif
  3148. #if M68000
  3149.       /* d,cy = r1 + (-1)
  3150.      m68000:    add    -1,d */
  3151.       PERFORM_ADD_CO(v, co, r1, VALUE(-1), ci);
  3152.       CRECURSE_2OP(ADD_CO, s1, s1, CNST(-1), 2, CY_JUST_SET);
  3153. #endif
  3154. #if I386 || PYR
  3155.       /* d,cy = r1 + (-1)
  3156.      i80386:    add    -1,d
  3157.      pyramid:    addw    $-1,d */
  3158.       PERFORM_ADD_CO(v, co, r1, VALUE(-1), ci);
  3159.       CRECURSE_2OP(ADD_CO, s1, s1, CNST(-1), 1, CY_JUST_SET);
  3160. #endif
  3161. #if M68000
  3162.       /* d,cy = r1 - (-1)
  3163.      m68000:    sub    -1,d */
  3164.       PERFORM_SUB_CO(v, co, r1, VALUE(-1), ci);
  3165.       CRECURSE_2OP(SUB_CO, s1, s1, CNST(-1), 2, CY_JUST_SET);
  3166. #endif
  3167. #if I386
  3168.       /* d,cy = r1 - (-1)
  3169.      i80386:    sub    -1,d */
  3170.       PERFORM_SUB_CO(v, co, r1, VALUE(-1), ci);
  3171.       CRECURSE_2OP(SUB_CO, s1, s1, CNST(-1), 1, CY_JUST_SET);
  3172. #endif
  3173. #if M68000 || I386
  3174.       /* d,cy = -r1
  3175.      m68000:    neg    d
  3176.      i80386:    neg    d */
  3177.       PERFORM_SUB_CO(v, co, VALUE(0), r1, ci);
  3178.       CRECURSE_2OP(SUB_CO, s1, CNST(0), s1, 1, CY_JUST_SET);
  3179. #endif
  3180. #if SH
  3181.       /* d = 0 - r1 - cy
  3182.      sh:        neg    d */
  3183.       PERFORM_SUB(v, co, VALUE(0), r1, ci);
  3184.       CRECURSE_NEW(SUB, n_values, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3185. #endif
  3186. #if PYR
  3187.       /* d,cy = 0 + (-r1)
  3188.      pyramid:    rsubw    $0,d */
  3189.       PERFORM_ADC_CO(v, co, VALUE(0), r1, ci);
  3190.       CRECURSE_2OP(ADC_CO, s1, CNST(0), s1, 1, CY_JUST_SET);
  3191. #endif
  3192. #if I386
  3193.       PERFORM_BSF86(v, co, r1, ci);
  3194.       CRECURSE_NEW(BSF86, n_values, s1, CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3195. #endif
  3196. #if SH
  3197.       /* Avoid silly sequences...  */
  3198.       if (allowed_cost > 1)
  3199.     {
  3200.       PERFORM_DECR_CYEQ(v, co, r1, VALUE(1), ci);
  3201.       CRECURSE_2OP(DECR_CYEQ, s1, s1, CNST(1), 1, CY_JUST_SET);
  3202.     }
  3203. #endif
  3204.     }
  3205.  
  3206. #if MC68020            /* don't do this for plain 68000 */
  3207.   /* kludge for immediate shift on 68k */
  3208.   if (last_dest >= 0 && last_dest == n_values - 1
  3209.       && values[last_dest] > 8        /* bogus, should use VALUE(..) */
  3210.       && values[last_dest] < 32        /* bogus, should use VALUE(..) */
  3211.       && sequence[n_insns - 1].opcode == COPY)
  3212.     {
  3213.       for (s1 = n_values - 2; s1 >= 0; s1--)
  3214.     {
  3215.       r1 = values[s1];
  3216.  
  3217.       PERFORM_LSHIFTR_CO(v, co, r1, values[last_dest], ci);
  3218.       CRECURSE_2OP(LSHIFTR_CO, s1, s1, last_dest, 1, CY_JUST_SET);
  3219.  
  3220.       PERFORM_ASHIFTR_CO(v, co, r1, values[last_dest], ci);
  3221.       CRECURSE_2OP(ASHIFTR_CO, s1, s1, last_dest, 1, CY_JUST_SET);
  3222.  
  3223.       PERFORM_SHIFTL_CO(v, co, r1, values[last_dest], ci);
  3224.       CRECURSE_2OP(SHIFTL_CO, s1, s1, last_dest, 1, CY_JUST_SET);
  3225.  
  3226.       PERFORM_ROTATEL_CO(v, co, r1, values[last_dest], ci);
  3227.       CRECURSE_2OP(ROTATEL_CO, s1, s1, last_dest, 1, CY_JUST_SET);
  3228.  
  3229.       PERFORM_ROTATER_CO(v, co, r1, values[last_dest], ci);
  3230.       CRECURSE_2OP(ROTATER_CO, s1, s1, last_dest, 1, CY_JUST_SET);
  3231.     }
  3232.     }
  3233. #endif
  3234.  
  3235.   /* Instructions that write to a new register and just depend on carry.  */
  3236.   if (ci >= 0
  3237. #if !SH /* We have to clear carry for addc, subc, and negc */
  3238.       && (prune_hint & CY_0) == 0
  3239. #endif
  3240.       && flag_use_carry
  3241.       && (allowed_cost <= 1 ? ((prune_hint & CY_JUST_SET) != 0) : 1))
  3242.     {
  3243. #if SH
  3244.       /* d = cy, cy = cy
  3245.      sh:        movt    d */
  3246.       PERFORM_ADD_CI(v, co, VALUE(0), VALUE(0), ci);
  3247.       CRECURSE_NEW(ADD_CI, n_values, CNST(0), CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3248. #endif
  3249. #if M68000 || I386 || SH
  3250.       /* d = -cy, cy = cy
  3251.      m68000:    subx    d,d
  3252.      i80386:    sbb    d,d
  3253.      sh:        subc    d,d */
  3254.       PERFORM_SUB_CIO(v, co, VALUE(0), VALUE(0), ci);
  3255.       CRECURSE_NEW(SUB_CIO, n_values, n_values, n_values, 1, prune_hint & ~CY_JUST_SET);
  3256. #endif
  3257. #if PYR
  3258.       /* d = -1 + cy, cy = cy
  3259.      pyramid:    subwb    d,d */
  3260.       PERFORM_ADC_CIO(v, co, VALUE(0), VALUE(0), ci);
  3261.       CRECURSE_NEW(ADC_CIO, n_values, n_values, n_values, 1, prune_hint & ~CY_JUST_SET);
  3262. #endif
  3263. #if I386 /* slow on m68000 */
  3264. /* ??? make new section for this, and conditionalize it on allowed_cost > 1 ??? */
  3265.       /* i80386:    cmc */
  3266.       co = ci ^ 1;
  3267.       CRECURSE_2OP(COMCY, n_values, n_values, n_values, 1, CY_JUST_SET);
  3268. #endif
  3269.     }
  3270.  
  3271.   /* Move instructions and instructions that just set carry.
  3272.      Don't do this if we are just permitted to do one more instruction.  */
  3273.   if (allowed_cost > 1)
  3274.     {
  3275. #if M68000 || I386 || PYR || SH
  3276.       /* d = 0
  3277.      m68000:    moveq    0,d
  3278.      i80386:    movl    $0,d
  3279.      pyramid:    movw    0,d
  3280.      sh:        mov    #0,d */
  3281.       PERFORM_COPY(v, co, VALUE(0), ci);
  3282.       CRECURSE_NEW(COPY, n_values, CNST(0), CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3283. #endif
  3284. #if M68000 || I386
  3285.       /* d = 0, cy = 0
  3286.      m68000:    sub    d,d
  3287.      i80386:    sub    d,d */
  3288.       PERFORM_SUB_CO(v, co, r1, r1, ci);
  3289.       CRECURSE_NEW(SUB_CO, n_values, n_values, n_values, 1, CY_JUST_SET | CY_0);
  3290. #endif
  3291. #if PYR
  3292.       /* d = 0, cy = 0
  3293.      pyramid:    subw    d,d */
  3294.       PERFORM_ADC_CO(v, co, r1, r1, ci);
  3295.       CRECURSE_NEW(ADC_CO, n_values, n_values, n_values, 1, CY_JUST_SET | CY_0);
  3296. #endif
  3297. #if MC68020        /* used for shifting, don't do this for plain 68000 */
  3298.       /* d = 31
  3299.      m68000:    moveq    31,d */
  3300.       PERFORM_COPY(v, co, VALUE(BITS_PER_WORD-1), ci);
  3301.       CRECURSE_NEW(COPY, n_values, CNST(BITS_PER_WORD-1), CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3302. #endif
  3303. #if MC68020        /* used for shifting, don't do this for plain 68000 */
  3304.       if (flag_shifts)
  3305.     {
  3306.       int cnt;
  3307.       for (cnt = 9; cnt <= 30; cnt++)    /* 31 handled above */
  3308.         {
  3309.           /* d = <cnt>
  3310.          m68000:    moveq    <cnt>,d */
  3311.           PERFORM_COPY(v, co, VALUE(cnt), ci);
  3312.           CRECURSE_NEW(COPY, n_values, CNST(cnt), CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3313.         }
  3314.     }
  3315. #endif
  3316. #if M68000 || PYR || SH
  3317.       /* d = 1
  3318.      m68000:    moveq    1,d
  3319.      pyramid:    movw    $1,d
  3320.      sh:        mov    #1,d */
  3321.       PERFORM_COPY(v, co, VALUE(1), ci);
  3322.       CRECURSE_NEW(COPY, n_values, CNST(1), CNST(0), 1,  prune_hint & ~CY_JUST_SET);
  3323.       /* d = -1
  3324.      m68000:    moveq    -1,d
  3325.      pyramid:    movw    $-1,d
  3326.      sh:        mov    #-1,d */
  3327.       PERFORM_COPY(v, co, VALUE(-1), ci);
  3328.       CRECURSE_NEW(COPY, n_values, CNST(-1), CNST(0), 1, prune_hint & ~CY_JUST_SET);
  3329. #endif
  3330. #if M68000 || I386 || PYR    /* these cost 2 cost units */
  3331.       /* d = 0x80000000 */
  3332.       PERFORM_COPY(v, co, VALUE_MIN_SIGNED, ci);
  3333.       CRECURSE_NEW(COPY, n_values, CNST_0x80000000, CNST(0), 2, prune_hint & ~CY_JUST_SET);
  3334.  
  3335.       /* d = 0x7fffffff */
  3336.       PERFORM_COPY(v, co, VALUE_MAX_SIGNED, ci);
  3337.       CRECURSE_NEW(COPY, n_values, CNST_0x7FFFFFFF, CNST(0), 2, prune_hint & ~CY_JUST_SET);
  3338. #endif
  3339. #if SH
  3340.       /* sh:    sett */
  3341.       co = 1;
  3342.       CRECURSE_2OP(SETCY, n_values, n_values, n_values, 1, CY_JUST_SET | CY_1);
  3343.       /* sh:    clrt */
  3344.       co = 0;
  3345.       CRECURSE_2OP(CLRCY, n_values, n_values, n_values, 1, CY_JUST_SET | CY_0);
  3346. #endif
  3347.     }
  3348. #ifdef TIMING
  3349.   timings[allowed_cost] += cputime() - time_start;
  3350. #endif
  3351. }
  3352. #endif
  3353.  
  3354. #if I960
  3355. /* Missing insns:
  3356.  * cmpdeco, cmpinco, cmpdeci and cmpinci.  How are conditions set?  Signed
  3357.    or unsigned?
  3358.  * All i960 insns accept small immediate values.  Try more cases, like lhs of
  3359.    shifts with rhs a register, etc.
  3360.  */
  3361. void
  3362. MAKENAME(synth) (insn_t *sequence,
  3363.          int n_insns,
  3364.          word *values,
  3365.          int n_values,
  3366.          word goal_value,
  3367.          int allowed_cost,
  3368.          int ci,
  3369.          int prune_hint)
  3370. {
  3371.   int s1, s2;
  3372.   word v, r1, r2;
  3373.   int co;
  3374.   int last_dest;
  3375.  
  3376. #ifdef TIMING
  3377.   unsigned long time_start = cputime();
  3378. #endif
  3379.  
  3380.   if (n_insns > 0)
  3381.     last_dest = sequence[n_insns - 1].d;
  3382.   else
  3383.     last_dest = -1;
  3384.  
  3385. /* Summary of interesting i960 instructions:
  3386.         Jx clocks  cc-in  cc-out
  3387. move        1    -    -
  3388. addo        1    -    -
  3389. addc        1    -c-    0cc
  3390. subo        1    -    -
  3391. subc        1    -c-    0cc
  3392. not        1    -    -
  3393. and        1    -    -
  3394. andnot,notand    1    -    -
  3395. or        1    -    -
  3396. ornot,notor    1    -    -
  3397. nand        1    -    -
  3398. nor        1    -    -
  3399. xor        1    -    -
  3400. xnor        1    -    -
  3401.  
  3402. extract        7    -    -
  3403. rotate        1    -    -
  3404. shlo        1    -    -
  3405. shro        1    -    -
  3406. shri        1    -    -
  3407. shrdi        6    -    -
  3408.  
  3409. alterbit    1    -c-    -
  3410. setbit        1    -    -
  3411. clrbit        1    -    -
  3412. chkbit        1    -    -c-
  3413. notbit        1    -    -
  3414. scanbit        5    -    -
  3415. spanbit        6    -    -
  3416.  
  3417. cmpdeco        1    -    ccc
  3418. cmpinco        1    -    ccc
  3419. cmpi        1    -    ccc
  3420. cmpo        1    -    ccc
  3421. testCC        4    ccc    -
  3422.  
  3423. Conditionally:
  3424. selCC        1    ccc    -
  3425. addoCC        1    ccc    -
  3426. suboCC        1    ccc    -
  3427. concmpi        1    c--    ccc
  3428. concmpo        1    c--    ccc
  3429. */
  3430.  
  3431.   /* Binary operations with carry-in.  */
  3432.   if (ci >= 0 && flag_use_carry)
  3433.     {
  3434.       for (s1 = n_values - 1; s1 >= 0; s1--)
  3435.     {
  3436.       r1 = values[s1];
  3437.       for (s2 = s1 - 1; s2 >= 0; s2--)
  3438.         {
  3439.           int dr;
  3440.           r2 = values[s2];
  3441.  
  3442.           if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  3443.         {
  3444.           /* We are in a leaf node.  CY was not set (to 0, 1 or to
  3445.              a data dependent value) by the previous insn.  Therefore,
  3446.              one of the input operands has to be the result operand of
  3447.              the previous insn for that insn to be meaningful.  */
  3448.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  3449.             continue;
  3450.         }
  3451.  
  3452.           /* i960:        addc */
  3453.           PERFORM_ADDC_960(v, co, r1, r2, ci);
  3454.           RECURSE(ADDC_960, s1, s2, CY_JUST_SET);
  3455.           /* i960:        subc */
  3456.           PERFORM_SUBC_960(v, co, r1, r2, ci);
  3457.           RECURSE(SUBC_960, s1, s2, CY_JUST_SET);
  3458.           PERFORM_SUBC_960(v, co, r2, r1, ci);
  3459.           RECURSE(SUBC_960, s2, s1, CY_JUST_SET);
  3460. #if I960B
  3461.           /* i960:        selCC r1,r2,d */
  3462.           PERFORM_SEL_NO_960(v, co, r1, r2, ci);
  3463.           RECURSE(SEL_NO_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3464.           PERFORM_SEL_G_960(v, co, r1, r2, ci);
  3465.           RECURSE(SEL_G_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3466.           PERFORM_SEL_E_960(v, co, r1, r2, ci);
  3467.           RECURSE(SEL_E_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3468.           PERFORM_SEL_GE_960(v, co, r1, r2, ci);
  3469.           RECURSE(SEL_GE_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3470.           PERFORM_SEL_L_960(v, co, r1, r2, ci);
  3471.           RECURSE(SEL_L_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3472.           PERFORM_SEL_NE_960(v, co, r1, r2, ci);
  3473.           RECURSE(SEL_NE_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3474.           PERFORM_SEL_LE_960(v, co, r1, r2, ci);
  3475.           RECURSE(SEL_LE_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3476.           PERFORM_SEL_O_960(v, co, r1, r2, ci);
  3477.           RECURSE(SEL_O_960, s1, s2, prune_hint & ~CY_JUST_SET);
  3478. #endif
  3479.           /* i960:        concmpoCC r1,r2 */
  3480.           PERFORM_CONCMPO_960(v, co, r1, r2, ci);
  3481.           CRECURSE_2OP(CONCMPO_960, n_values, s1, s2, 1, CY_JUST_SET);
  3482.           /* i960:        concmpoCC r2,r1 */
  3483.           PERFORM_CONCMPO_960(v, co, r2, r1, ci);
  3484.           CRECURSE_2OP(CONCMPO_960, n_values, s2, s1, 1, CY_JUST_SET);
  3485.           /* i960:        concmpiCC r1,r2 */
  3486.           PERFORM_CONCMPI_960(v, co, r1, r2, ci);
  3487.           CRECURSE_2OP(CONCMPI_960, n_values, s1, s2, 1, CY_JUST_SET);
  3488.           /* i960:        concmpiCC r2,r1 */
  3489.           PERFORM_CONCMPI_960(v, co, r2, r1, ci);
  3490.           CRECURSE_2OP(CONCMPI_960, n_values, s2, s1, 1, CY_JUST_SET);
  3491.         }
  3492.     }
  3493.     }
  3494.  
  3495. #if I960B
  3496.   /* Binary conditionally executed operations with carry-in.  */
  3497.   if (ci >= 0 && flag_use_carry)
  3498.     {
  3499.       for (s1 = n_values - 1; s1 >= 0; s1--)
  3500.     {
  3501.       r1 = values[s1];
  3502.       for (s2 = s1 - 1; s2 >= 0; s2--)
  3503.         {
  3504.           int dr;
  3505.           r2 = values[s2];
  3506.           /* I960 conditional add and subtract instructions need special
  3507.          treatment.  We let all other instructions assign the next
  3508.          higher-numbered register, but we can't do that here since
  3509.          these insns leave the register unchanged if the instruction
  3510.          condition is not satisfied.  Instead we let these instructions
  3511.          non-deterministically overwrite all already-defined
  3512.          registers.  */
  3513.           for (dr = n_values - 1; dr >= 0; dr--)
  3514.         {
  3515.           if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  3516.             {
  3517.               /* We are in a leaf node and CY was not set (to 1 or to
  3518.              a data dependent value) by the previous insn.  One of
  3519.              the input operands has to be the result operand of
  3520.              the previous insn for that insn to be meaningful.
  3521.              For these instructions, we have to consider the
  3522.              destination as an input operand, since its result is
  3523.              not dying here.  */
  3524.               if (last_dest >= 0 && dr != last_dest
  3525.               && s1 != last_dest && s2 != last_dest)
  3526.             continue;
  3527.             }
  3528.  
  3529.           /* i960:        addoCC r1,r2 */
  3530.           v = values[dr];
  3531.           PERFORM_ADDO_NO_960(v, co, r1, r2, ci);
  3532.           CRECURSE_2OP(ADDO_NO_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3533.           v = values[dr];
  3534.           PERFORM_ADDO_G_960(v, co, r1, r2, ci);
  3535.           CRECURSE_2OP(ADDO_G_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3536.           v = values[dr];
  3537.           PERFORM_ADDO_E_960(v, co, r1, r2, ci);
  3538.           CRECURSE_2OP(ADDO_E_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3539.           v = values[dr];
  3540.           PERFORM_ADDO_GE_960(v, co, r1, r2, ci);
  3541.           CRECURSE_2OP(ADDO_GE_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3542.           v = values[dr];
  3543.           PERFORM_ADDO_L_960(v, co, r1, r2, ci);
  3544.           CRECURSE_2OP(ADDO_L_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3545.           v = values[dr];
  3546.           PERFORM_ADDO_NE_960(v, co, r1, r2, ci);
  3547.           CRECURSE_2OP(ADDO_NE_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3548.           v = values[dr];
  3549.           PERFORM_ADDO_LE_960(v, co, r1, r2, ci);
  3550.           CRECURSE_2OP(ADDO_LE_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3551.           v = values[dr];
  3552.           PERFORM_ADDO_O_960(v, co, r1, r2, ci);
  3553.           CRECURSE_2OP(ADDO_O_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3554.  
  3555.           /* i960:        suboCC r2,r1 */
  3556.           v = values[dr];
  3557.           PERFORM_SUBO_NO_960(v, co, r1, r2, ci);
  3558.           CRECURSE_2OP(SUBO_NO_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3559.           v = values[dr];
  3560.           PERFORM_SUBO_G_960(v, co, r1, r2, ci);
  3561.           CRECURSE_2OP(SUBO_G_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3562.           v = values[dr];
  3563.           PERFORM_SUBO_E_960(v, co, r1, r2, ci);
  3564.           CRECURSE_2OP(SUBO_E_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3565.           v = values[dr];
  3566.           PERFORM_SUBO_GE_960(v, co, r1, r2, ci);
  3567.           CRECURSE_2OP(SUBO_GE_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3568.           v = values[dr];
  3569.           PERFORM_SUBO_L_960(v, co, r1, r2, ci);
  3570.           CRECURSE_2OP(SUBO_L_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3571.           v = values[dr];
  3572.           PERFORM_SUBO_NE_960(v, co, r1, r2, ci);
  3573.           CRECURSE_2OP(SUBO_NE_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3574.           v = values[dr];
  3575.           PERFORM_SUBO_LE_960(v, co, r1, r2, ci);
  3576.           CRECURSE_2OP(SUBO_LE_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3577.           v = values[dr];
  3578.           PERFORM_SUBO_O_960(v, co, r1, r2, ci);
  3579.           CRECURSE_2OP(SUBO_O_960, dr, s1, s2, 1, prune_hint & ~CY_JUST_SET);
  3580.  
  3581.           /* i960:        suboCC r1,r2 */
  3582.           v = values[dr];
  3583.           PERFORM_SUBO_NO_960(v, co, r2, r1, ci);
  3584.           CRECURSE_2OP(SUBO_NO_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3585.           v = values[dr];
  3586.           PERFORM_SUBO_G_960(v, co, r2, r1, ci);
  3587.           CRECURSE_2OP(SUBO_G_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3588.           v = values[dr];
  3589.           PERFORM_SUBO_E_960(v, co, r2, r1, ci);
  3590.           CRECURSE_2OP(SUBO_E_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3591.           v = values[dr];
  3592.           PERFORM_SUBO_GE_960(v, co, r2, r1, ci);
  3593.           CRECURSE_2OP(SUBO_GE_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3594.           v = values[dr];
  3595.           PERFORM_SUBO_L_960(v, co, r2, r1, ci);
  3596.           CRECURSE_2OP(SUBO_L_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3597.           v = values[dr];
  3598.           PERFORM_SUBO_NE_960(v, co, r2, r1, ci);
  3599.           CRECURSE_2OP(SUBO_NE_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3600.           v = values[dr];
  3601.           PERFORM_SUBO_LE_960(v, co, r2, r1, ci);
  3602.           CRECURSE_2OP(SUBO_LE_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3603.           v = values[dr];
  3604.           PERFORM_SUBO_O_960(v, co, r2, r1, ci);
  3605.           CRECURSE_2OP(SUBO_O_960, dr, s2, s1, 1, prune_hint & ~CY_JUST_SET);
  3606.         }
  3607.         }
  3608.     }
  3609.     }
  3610. #endif
  3611.  
  3612.   /* Binary operations without carry-in.  */
  3613.   for (s1 = n_values - 1; s1 >= 0; s1--)
  3614.     {
  3615.       r1 = values[s1];
  3616.       for (s2 = s1 - 1; s2 >= 0; s2--)
  3617.     {
  3618.       r2 = values[s2];
  3619.  
  3620.       if (allowed_cost <= 1)
  3621.         {
  3622.           /* We are in a leaf node.  One of the input operands has to be
  3623.          the result operand of the previous insn for that insn to be
  3624.          meaningful.  */
  3625.           if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
  3626.         continue;
  3627.         }
  3628.  
  3629.       /* i960:    cmpo */
  3630.       PERFORM_CMPO_960(v, co, r1, r2, ci);
  3631.       CRECURSE_2OP(CMPO_960, n_values, s1, s2, 1, CY_JUST_SET);
  3632.       PERFORM_CMPO_960(v, co, r2, r1, ci);
  3633.       CRECURSE_2OP(CMPO_960, n_values, s2, s1, 1, CY_JUST_SET);
  3634.       /* i960:    cmpi */
  3635.       PERFORM_CMPI_960(v, co, r1, r2, ci);
  3636.       CRECURSE_2OP(CMPI_960, n_values, s1, s2, 1, CY_JUST_SET);
  3637.       PERFORM_CMPI_960(v, co, r2, r1, ci);
  3638.       CRECURSE_2OP(CMPI_960, n_values, s2, s1, 1, CY_JUST_SET);
  3639.  
  3640.       /* i960:    addo */
  3641.       PERFORM_ADD(v, co, r1, r2, ci);
  3642.       RECURSE(ADD, s1, s2, prune_hint & ~CY_JUST_SET);
  3643.       /* i960:    subo */
  3644.       PERFORM_SUB(v, co, r1, r2, ci);
  3645.       RECURSE(SUB, s1, s2, prune_hint & ~CY_JUST_SET);
  3646.       PERFORM_SUB(v, co, r2, r1, ci);
  3647.       RECURSE(SUB, s2, s1, prune_hint & ~CY_JUST_SET);
  3648.  
  3649.       PERFORM_AND(v, co, r1, r2, ci);
  3650.       RECURSE(AND, s1, s2, prune_hint & ~CY_JUST_SET);
  3651.       PERFORM_IOR(v, co, r1, r2, ci);
  3652.       RECURSE(IOR, s1, s2, prune_hint & ~CY_JUST_SET);
  3653.       PERFORM_XOR(v, co, r1, r2, ci);
  3654.       RECURSE(XOR, s1, s2, prune_hint & ~CY_JUST_SET);
  3655.       PERFORM_ANDC(v, co, r1, r2, ci);
  3656.       RECURSE(ANDC, s1, s2, prune_hint & ~CY_JUST_SET);
  3657.       PERFORM_ANDC(v, co, r2, r1, ci);
  3658.       RECURSE(ANDC, s2, s1, prune_hint & ~CY_JUST_SET);
  3659.       PERFORM_IORC(v, co, r1, r2, ci);
  3660.       RECURSE(IORC, s1, s2, prune_hint & ~CY_JUST_SET);
  3661.       PERFORM_IORC(v, co, r2, r1, ci);
  3662.       RECURSE(IORC, s2, s1, prune_hint & ~CY_JUST_SET);
  3663.       PERFORM_EQV(v, co, r1, r2, ci);
  3664.       RECURSE(EQV, s1, s2, prune_hint & ~CY_JUST_SET);
  3665.       PERFORM_NAND(v, co, r1, r2, ci);
  3666.       RECURSE(NAND, s1, s2, prune_hint & ~CY_JUST_SET);
  3667.       PERFORM_NOR(v, co, r1, r2, ci);
  3668.       RECURSE(NOR, s1, s2, prune_hint & ~CY_JUST_SET);
  3669.  
  3670.       PERFORM_SHIFTL_NT (v, co, r1, r2, ci);
  3671.       RECURSE(SHIFTL_NT, s1, s2, prune_hint & ~CY_JUST_SET);
  3672.       PERFORM_SHIFTL_NT (v, co, r2, r1, ci);
  3673.       RECURSE(SHIFTL_NT, s2, s1, prune_hint & ~CY_JUST_SET);
  3674.  
  3675.       PERFORM_LSHIFTR_NT (v, co, r1, r2, ci);
  3676.       RECURSE(LSHIFTR_NT, s1, s2, prune_hint & ~CY_JUST_SET);
  3677.       PERFORM_LSHIFTR_NT (v, co, r2, r1, ci);
  3678.       RECURSE(LSHIFTR_NT, s2, s1, prune_hint & ~CY_JUST_SET);
  3679.  
  3680.       PERFORM_ASHIFTR_NT (v, co, r1, r2, ci);
  3681.       RECURSE(ASHIFTR_NT, s1, s2, prune_hint & ~CY_JUST_SET);
  3682.       PERFORM_ASHIFTR_NT (v, co, r2, r1, ci);
  3683.       RECURSE(ASHIFTR_NT, s2, s1, prune_hint & ~CY_JUST_SET);
  3684.     }
  3685.     }
  3686.  
  3687.   /* Unary operations with carry-in.  */
  3688.   if (ci >= 0 && flag_use_carry)
  3689.     {
  3690.       for (s1 = n_values - 1; s1 >= 0; s1--)
  3691.     {
  3692.       int dr;
  3693.       r1 = values[s1];
  3694.  
  3695.       if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  3696.         {
  3697.           /* We are in a leaf node and CY was not set (to 1 or to a
  3698.          data dependent value) by the previous insn.  Therefore,
  3699.          the input operand has to be the result operand of the
  3700.          previous insn for that insn to be meaningful.  */
  3701.           if (last_dest >= 0 && s1 != last_dest)
  3702.         continue;
  3703.         }
  3704.  
  3705.       /* d,cy = 2*r1 + cy
  3706.          i960:    addc    s1,s1,d */
  3707.       PERFORM_ADDC_960(v, co, r1, r1, ci);
  3708.       RECURSE(ADDC_960, s1, s1, CY_JUST_SET);
  3709.       /* d,cy = r1 + cy - 1
  3710.          i960:    subc    r0,s1,d */
  3711.       PERFORM_ADDC_960(v, co, r1, VALUE(-1), ci);
  3712.       RECURSE(ADDC_960, s1, CNST(-1), CY_JUST_SET);
  3713.       /* d,cy = r1 + cy
  3714.          i960:    addc    s1,0,d */
  3715.       PERFORM_ADDC_960(v, co, r1, VALUE(0), ci);
  3716.       RECURSE(ADDC_960, s1, CNST(0), CY_JUST_SET);
  3717.       /* d,cy = ~r1 + cy
  3718.          i960:    subc    s1,0,d */
  3719.       PERFORM_SUBC_960(v, co, VALUE(0), r1, ci);
  3720.       RECURSE(SUBC_960, CNST(0), s1, CY_JUST_SET);
  3721. #if I960B
  3722.       /* i960:        selCC r1,0,d */
  3723.       PERFORM_SEL_NO_960(v, co, r1, VALUE(0), ci);
  3724.       RECURSE(SEL_NO_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3725.       PERFORM_SEL_G_960(v, co, r1, VALUE(0), ci);
  3726.       RECURSE(SEL_G_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3727.       PERFORM_SEL_E_960(v, co, r1, VALUE(0), ci);
  3728.       RECURSE(SEL_E_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3729.       PERFORM_SEL_GE_960(v, co, r1, VALUE(0), ci);
  3730.       RECURSE(SEL_GE_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3731.       PERFORM_SEL_L_960(v, co, r1, VALUE(0), ci);
  3732.       RECURSE(SEL_L_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3733.       PERFORM_SEL_NE_960(v, co, r1, VALUE(0), ci);
  3734.       RECURSE(SEL_NE_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3735.       PERFORM_SEL_LE_960(v, co, r1, VALUE(0), ci);
  3736.       RECURSE(SEL_LE_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3737.       PERFORM_SEL_O_960(v, co, r1, VALUE(0), ci);
  3738.       RECURSE(SEL_O_960, s1, CNST(0), prune_hint & ~CY_JUST_SET);
  3739.  
  3740.       /* i960:        selCC r1,1,d */
  3741.       PERFORM_SEL_NO_960(v, co, r1, VALUE(1), ci);
  3742.       RECURSE(SEL_NO_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3743.       PERFORM_SEL_G_960(v, co, r1, VALUE(1), ci);
  3744.       RECURSE(SEL_G_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3745.       PERFORM_SEL_E_960(v, co, r1, VALUE(1), ci);
  3746.       RECURSE(SEL_E_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3747.       PERFORM_SEL_GE_960(v, co, r1, VALUE(1), ci);
  3748.       RECURSE(SEL_GE_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3749.       PERFORM_SEL_L_960(v, co, r1, VALUE(1), ci);
  3750.       RECURSE(SEL_L_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3751.       PERFORM_SEL_NE_960(v, co, r1, VALUE(1), ci);
  3752.       RECURSE(SEL_NE_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3753.       PERFORM_SEL_LE_960(v, co, r1, VALUE(1), ci);
  3754.       RECURSE(SEL_LE_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3755.       PERFORM_SEL_O_960(v, co, r1, VALUE(1), ci);
  3756.       RECURSE(SEL_O_960, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3757. #endif
  3758.       /* i960:        concmpoCC r1,r2 */
  3759.       PERFORM_CONCMPO_960(v, co, r1, VALUE(0), ci);
  3760.       CRECURSE_2OP(CONCMPO_960, n_values, s1, CNST(0), 1, CY_JUST_SET);
  3761.       /* i960:        concmpoCC r2,r1 */
  3762.       PERFORM_CONCMPO_960(v, co, VALUE(0), r1, ci);
  3763.       CRECURSE_2OP(CONCMPO_960, n_values, CNST(0), s1, 1, CY_JUST_SET);
  3764.       /* i960:        concmpiCC r1,r2 */
  3765.       PERFORM_CONCMPI_960(v, co, r1, VALUE(0), ci);
  3766.       CRECURSE_2OP(CONCMPI_960, n_values, s1, CNST(0), 1, CY_JUST_SET);
  3767.       /* i960:        concmpiCC r2,r1 */
  3768.       PERFORM_CONCMPI_960(v, co, VALUE(0), r1, ci);
  3769.       CRECURSE_2OP(CONCMPI_960, n_values, CNST(0), s1, 1, CY_JUST_SET);
  3770.  
  3771.       /* i960:        concmpoCC r1,r2 */
  3772.       PERFORM_CONCMPO_960(v, co, r1, VALUE(1), ci);
  3773.       CRECURSE_2OP(CONCMPO_960, n_values, s1, CNST(1), 1, CY_JUST_SET);
  3774.       /* i960:        concmpoCC r2,r1 */
  3775.       PERFORM_CONCMPO_960(v, co, VALUE(1), r1, ci);
  3776.       CRECURSE_2OP(CONCMPO_960, n_values, CNST(1), s1, 1, CY_JUST_SET);
  3777.       /* i960:        concmpiCC r1,r2 */
  3778.       PERFORM_CONCMPI_960(v, co, r1, VALUE(1), ci);
  3779.       CRECURSE_2OP(CONCMPI_960, n_values, s1, CNST(1), 1, CY_JUST_SET);
  3780.       /* i960:        concmpiCC r2,r1 */
  3781.       PERFORM_CONCMPI_960(v, co, VALUE(1), r1, ci);
  3782.       CRECURSE_2OP(CONCMPI_960, n_values, CNST(1), s1, 1, CY_JUST_SET);
  3783.       {
  3784.         int cnt;
  3785.         for (cnt = 0; cnt < BITS_PER_WORD; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 1))
  3786.           {
  3787.         PERFORM_ALTERBIT(v, co, r1, VALUE(cnt), ci);
  3788.         RECURSE(ALTERBIT, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  3789.           }
  3790.       }
  3791.     }
  3792.     }
  3793.  
  3794. #if I960B
  3795.   /* Unary conditionally executed operations with carry-in.  */
  3796.   if (ci >= 0 && flag_use_carry)
  3797.     {
  3798.       for (s1 = n_values - 1; s1 >= 0; s1--)
  3799.     {
  3800.       int dr;
  3801.       r1 = values[s1];
  3802.  
  3803.       /* I960 conditional add and subtract instructions need special
  3804.          treatment.  See comment above.  */
  3805.       for (dr = n_values - 1; dr >= 0; dr--)
  3806.         {
  3807.           if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
  3808.         {
  3809.           /* We are in a leaf node and CY was not set (to 1 or to a
  3810.              data dependent value) by the previous insn.  Therefore
  3811.              one of the input operands has to be the result operand of
  3812.              the previous insn for that insn to be meaningful.
  3813.              For these instructions, we have to consider the
  3814.              destination as an input operand, since its result is
  3815.              not dying here.  */
  3816.           if (last_dest >= 0 && s1 != last_dest && dr != last_dest)
  3817.             continue;
  3818.         }
  3819.  
  3820.           /* i960:        addoCC r1,1,d */
  3821.           v = values[dr];
  3822.           PERFORM_ADDO_NO_960(v, co, r1, VALUE(1), ci);
  3823.           CRECURSE_2OP(ADDO_NO_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3824.           v = values[dr];
  3825.           PERFORM_ADDO_G_960(v, co, r1, VALUE(1), ci);
  3826.           CRECURSE_2OP(ADDO_G_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3827.           v = values[dr];
  3828.           PERFORM_ADDO_E_960(v, co, r1, VALUE(1), ci);
  3829.           CRECURSE_2OP(ADDO_E_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3830.           v = values[dr];
  3831.           PERFORM_ADDO_GE_960(v, co, r1, VALUE(1), ci);
  3832.           CRECURSE_2OP(ADDO_GE_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3833.           v = values[dr];
  3834.           PERFORM_ADDO_L_960(v, co, r1, VALUE(1), ci);
  3835.           CRECURSE_2OP(ADDO_L_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3836.           v = values[dr];
  3837.           PERFORM_ADDO_NE_960(v, co, r1, VALUE(1), ci);
  3838.           CRECURSE_2OP(ADDO_NE_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3839.           v = values[dr];
  3840.           PERFORM_ADDO_LE_960(v, co, r1, VALUE(1), ci);
  3841.           CRECURSE_2OP(ADDO_LE_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3842.           v = values[dr];
  3843.           PERFORM_ADDO_O_960(v, co, r1, VALUE(1), ci);
  3844.           CRECURSE_2OP(ADDO_O_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3845.  
  3846.           /* i960:        suboCC 1,r1,d */
  3847.           v = values[dr];
  3848.           PERFORM_SUBO_NO_960(v, co, r1, VALUE(1), ci);
  3849.           CRECURSE_2OP(SUBO_NO_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3850.           v = values[dr];
  3851.           PERFORM_SUBO_G_960(v, co, r1, VALUE(1), ci);
  3852.           CRECURSE_2OP(SUBO_G_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3853.           v = values[dr];
  3854.           PERFORM_SUBO_E_960(v, co, r1, VALUE(1), ci);
  3855.           CRECURSE_2OP(SUBO_E_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3856.           v = values[dr];
  3857.           PERFORM_SUBO_GE_960(v, co, r1, VALUE(1), ci);
  3858.           CRECURSE_2OP(SUBO_GE_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3859.           v = values[dr];
  3860.           PERFORM_SUBO_L_960(v, co, r1, VALUE(1), ci);
  3861.           CRECURSE_2OP(SUBO_L_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3862.           v = values[dr];
  3863.           PERFORM_SUBO_NE_960(v, co, r1, VALUE(1), ci);
  3864.           CRECURSE_2OP(SUBO_NE_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3865.           v = values[dr];
  3866.           PERFORM_SUBO_LE_960(v, co, r1, VALUE(1), ci);
  3867.           CRECURSE_2OP(SUBO_LE_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3868.           v = values[dr];
  3869.           PERFORM_SUBO_O_960(v, co, r1, VALUE(1), ci);
  3870.           CRECURSE_2OP(SUBO_O_960, dr, s1, CNST(1), 1, prune_hint & ~CY_JUST_SET);
  3871.  
  3872.           /* i960:        suboCC r1,1,d */
  3873.           v = values[dr];
  3874.           PERFORM_SUBO_NO_960(v, co, VALUE(1), r1, ci);
  3875.           CRECURSE_2OP(SUBO_NO_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3876.           v = values[dr];
  3877.           PERFORM_SUBO_G_960(v, co, VALUE(1), r1, ci);
  3878.           CRECURSE_2OP(SUBO_G_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3879.           v = values[dr];
  3880.           PERFORM_SUBO_E_960(v, co, VALUE(1), r1, ci);
  3881.           CRECURSE_2OP(SUBO_E_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3882.           v = values[dr];
  3883.           PERFORM_SUBO_GE_960(v, co, VALUE(1), r1, ci);
  3884.           CRECURSE_2OP(SUBO_GE_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3885.           v = values[dr];
  3886.           PERFORM_SUBO_L_960(v, co, VALUE(1), r1, ci);
  3887.           CRECURSE_2OP(SUBO_L_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3888.           v = values[dr];
  3889.           PERFORM_SUBO_NE_960(v, co, VALUE(1), r1, ci);
  3890.           CRECURSE_2OP(SUBO_NE_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3891.           v = values[dr];
  3892.           PERFORM_SUBO_LE_960(v, co, VALUE(1), r1, ci);
  3893.           CRECURSE_2OP(SUBO_LE_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3894.           v = values[dr];
  3895.           PERFORM_SUBO_O_960(v, co, VALUE(1), r1, ci);
  3896.           CRECURSE_2OP(SUBO_O_960, dr, CNST(1), s1, 1, prune_hint & ~CY_JUST_SET);
  3897.  
  3898.           /* i960:        suboCC r1,0,d */
  3899.           v = values[dr];
  3900.           PERFORM_SUBO_NO_960(v, co, VALUE(0), r1, ci);
  3901.           CRECURSE_2OP(SUBO_NO_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3902.           v = values[dr];
  3903.           PERFORM_SUBO_G_960(v, co, VALUE(0), r1, ci);
  3904.           CRECURSE_2OP(SUBO_G_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3905.           v = values[dr];
  3906.           PERFORM_SUBO_E_960(v, co, VALUE(0), r1, ci);
  3907.           CRECURSE_2OP(SUBO_E_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3908.           v = values[dr];
  3909.           PERFORM_SUBO_GE_960(v, co, VALUE(0), r1, ci);
  3910.           CRECURSE_2OP(SUBO_GE_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3911.           v = values[dr];
  3912.           PERFORM_SUBO_L_960(v, co, VALUE(0), r1, ci);
  3913.           CRECURSE_2OP(SUBO_L_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3914.           v = values[dr];
  3915.           PERFORM_SUBO_NE_960(v, co, VALUE(0), r1, ci);
  3916.           CRECURSE_2OP(SUBO_NE_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3917.           v = values[dr];
  3918.           PERFORM_SUBO_LE_960(v, co, VALUE(0), r1, ci);
  3919.           CRECURSE_2OP(SUBO_LE_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3920.           v = values[dr];
  3921.           PERFORM_SUBO_O_960(v, co, VALUE(0), r1, ci);
  3922.           CRECURSE_2OP(SUBO_O_960, dr, CNST(0), s1, 1, prune_hint & ~CY_JUST_SET);
  3923.         }
  3924.     }
  3925.     }
  3926. #endif
  3927.  
  3928.   /* Unary operations without carry-in.  */
  3929.   for (s1 = n_values - 1; s1 >= 0; s1--)
  3930.     {
  3931.       r1 = values[s1];
  3932.  
  3933.       if (allowed_cost <= 1)
  3934.     {
  3935.       /* We are in a leaf node.  The input operand has to be the result
  3936.          operand of the previous insns for that insn to be meaningful.  */
  3937.       if (last_dest >= 0 && s1 != last_dest)
  3938.         continue;
  3939.     }
  3940.  
  3941.       /* i960:    cmpo */
  3942.       PERFORM_CMPO_960(v, co, r1, VALUE(0), ci);
  3943.       CRECURSE_2OP(CMPO_960, n_values, s1, CNST(0), 1, CY_JUST_SET);
  3944.       PERFORM_CMPO_960(v, co, VALUE(0), r1, ci);
  3945.       CRECURSE_2OP(CMPO_960, n_values, CNST(0), s1, 1, CY_JUST_SET);
  3946.       /* i960:    cmpi */
  3947.       PERFORM_CMPI_960(v, co, r1, VALUE(0), ci);
  3948.       CRECURSE_2OP(CMPI_960, n_values, s1, CNST(0), 1, CY_JUST_SET);
  3949.       PERFORM_CMPI_960(v, co, VALUE(0), r1, ci);
  3950.       CRECURSE_2OP(CMPI_960, n_values, CNST(0), s1, 1, CY_JUST_SET);
  3951.  
  3952.       /* i960:    cmpo */
  3953.       PERFORM_CMPO_960(v, co, r1, VALUE(1), ci);
  3954.       CRECURSE_2OP(CMPO_960, n_values, s1, CNST(1), 1, CY_JUST_SET);
  3955.       PERFORM_CMPO_960(v, co, VALUE(1), r1, ci);
  3956.       CRECURSE_2OP(CMPO_960, n_values, CNST(1), s1, 1, CY_JUST_SET);
  3957.       /* i960:    cmpi */
  3958.       PERFORM_CMPI_960(v, co, r1, VALUE(1), ci);
  3959.       CRECURSE_2OP(CMPI_960, n_values, s1, CNST(1), 1, CY_JUST_SET);
  3960.       PERFORM_CMPI_960(v, co, VALUE(1), r1, ci);
  3961.       CRECURSE_2OP(CMPI_960, n_values, CNST(1), s1, 1, CY_JUST_SET);
  3962.  
  3963.       /* d = r1 & 1
  3964.      i960:        and    s1,1,d */
  3965.       PERFORM_AND(v, co, r1, VALUE(1), ci);
  3966.       RECURSE(AND, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3967.  
  3968.       /* d = r1 ^ 1
  3969.      i960:        xor    s1,1,d */
  3970.       PERFORM_XOR(v, co, r1, VALUE(1), ci);
  3971.       RECURSE(XOR, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3972.       /* d = ~r1
  3973.      i960:        not    s1,d */
  3974.       PERFORM_SUB(v, co, VALUE(-1), r1, ci);
  3975.       RECURSE(SUB, CNST(-1), s1, prune_hint & ~CY_JUST_SET);
  3976.       /* d = r1 + 1
  3977.      i960:        add    s1,1,d */
  3978.       PERFORM_ADD(v, co, r1, VALUE(1), ci);
  3979.       RECURSE(ADD, s1, CNST(1), prune_hint & ~CY_JUST_SET);
  3980.       /* d = r1 + -1
  3981.      i960:        sub    1,s1,d */
  3982.       PERFORM_ADD(v, co, r1, VALUE(-1), ci);
  3983.       RECURSE(ADD, s1, CNST(-1), prune_hint & ~CY_JUST_SET);
  3984.       /* d = -r1
  3985.      i960:        sub    s1,0,d */
  3986.       PERFORM_SUB(v, co, VALUE(0), r1, ci);
  3987.       RECURSE(SUB, CNST(0), s1, prune_hint & ~CY_JUST_SET);
  3988.  
  3989.       PERFORM_LSHIFTR_NT (v, co, VALUE(1), r1, ci);
  3990.       RECURSE(LSHIFTR_NT, CNST(1), s1, prune_hint & ~CY_JUST_SET);
  3991.  
  3992.       {
  3993.     int cnt;
  3994.     for (cnt = 1; cnt < BITS_PER_WORD; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 2))
  3995.       {
  3996.         PERFORM_LSHIFTR(v, co, r1, VALUE(cnt), ci);
  3997.         RECURSE(LSHIFTR, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  3998.  
  3999.         PERFORM_ASHIFTR(v, co, r1, VALUE(cnt), ci);
  4000.         RECURSE(ASHIFTR, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  4001.  
  4002.         PERFORM_SHIFTL(v, co, r1, VALUE(cnt), ci);
  4003.         RECURSE(SHIFTL, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  4004.  
  4005.         PERFORM_ROTATEL(v, co, r1, VALUE(cnt), ci);
  4006.         RECURSE(ROTATEL, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  4007.       }
  4008.     for (cnt = 0; cnt < BITS_PER_WORD; cnt += (flag_shifts ? 1 : BITS_PER_WORD - 1))
  4009.       {
  4010.         PERFORM_SETBIT(v, co, r1, VALUE(cnt), ci);
  4011.         RECURSE(SETBIT, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  4012.  
  4013.         PERFORM_CLRBIT(v, co, r1, VALUE(cnt), ci);
  4014.         RECURSE(CLRBIT, s1, CNST(cnt), prune_hint & ~CY_JUST_SET);
  4015.  
  4016.         PERFORM_CHKBIT(v, co, r1, VALUE(cnt), ci);
  4017.         CRECURSE_2OP(CHKBIT, n_values, s1, CNST(cnt), 1, CY_JUST_SET);
  4018.       }
  4019.       }
  4020.  
  4021.       /* Copy register->register because of conditional insns.  */
  4022.       /* d = 0
  4023.      alpha:        bis    r1,r1,d */
  4024.       PERFORM_COPY(v, co, r1, ci);
  4025.       RECURSE(COPY, s1, 0, prune_hint & ~CY_JUST_SET);
  4026.     }
  4027.  
  4028.   /* 0-ary instructions, just dependent on carry.  */
  4029.   if (ci >= 0 && flag_use_carry
  4030.       && (allowed_cost <= 1 ? ((prune_hint & CY_JUST_SET) != 0) : 1))
  4031.     {
  4032.       /* We don't do "0 - 1 - cy" or "0 + 1 + cy" here.  It would
  4033.      probably give very few new sequences. */
  4034.       /* d = cy, cy = 0.
  4035.      i960:        addc    0,0,d */
  4036.       PERFORM_ADDC_960(v, co, VALUE(0), VALUE(0), ci);
  4037.       RECURSE(ADDC_960, CNST(0), CNST(0), CY_JUST_SET | CY_0);
  4038.       /* d = -1 + cy, cy = cy
  4039.      i960:        subc    0,0,d */
  4040.       PERFORM_SUBC_960(v, co, VALUE(0), VALUE(0), ci);
  4041.       RECURSE(SUBC_960, CNST(0), CNST(0), prune_hint & ~CY_JUST_SET);
  4042.  
  4043. #if I960B
  4044.       /* i960:        selCC 1,0,d */
  4045.       PERFORM_SEL_NO_960(v, co, VALUE(1), VALUE(0), ci);
  4046.       RECURSE(SEL_NO_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4047.       PERFORM_SEL_G_960(v, co, VALUE(1), VALUE(0), ci);
  4048.       RECURSE(SEL_G_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4049.       PERFORM_SEL_E_960(v, co, VALUE(1), VALUE(0), ci);
  4050.       RECURSE(SEL_E_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4051.       PERFORM_SEL_GE_960(v, co, VALUE(1), VALUE(0), ci);
  4052.       RECURSE(SEL_GE_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4053.       PERFORM_SEL_L_960(v, co, VALUE(1), VALUE(0), ci);
  4054.       RECURSE(SEL_L_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4055.       PERFORM_SEL_NE_960(v, co, VALUE(1), VALUE(0), ci);
  4056.       RECURSE(SEL_NE_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4057.       PERFORM_SEL_LE_960(v, co, VALUE(1), VALUE(0), ci);
  4058.       RECURSE(SEL_LE_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4059.       PERFORM_SEL_O_960(v, co, VALUE(1), VALUE(0), ci);
  4060.       RECURSE(SEL_O_960, CNST(1), CNST(0), prune_hint & ~CY_JUST_SET);
  4061. #endif
  4062.     }
  4063.  
  4064.   /* Move instructions.
  4065.      Don't do this if we are just permitted to do one more instruction.  */
  4066.   if (allowed_cost > 1)
  4067.     {
  4068.       /* d = 0x80000000
  4069.      i960:        setbit    31,0,d */
  4070.       PERFORM_COPY(v, co, VALUE_MIN_SIGNED, ci);
  4071.       RECURSE(COPY, CNST_0x80000000, 0, prune_hint & ~CY_JUST_SET);
  4072.       /* d = -1
  4073.      i960:        subo    1,0,d */
  4074.       PERFORM_COPY(v, co, VALUE(-1), ci);
  4075.       RECURSE(COPY, CNST(-1), 0, prune_hint & ~CY_JUST_SET);
  4076.       /* d = 1
  4077.      i960:        mov    1,d */
  4078.       PERFORM_COPY(v, co, VALUE(1), ci);
  4079.       RECURSE(COPY, CNST(1), 0, prune_hint & ~CY_JUST_SET);
  4080.       /* d = 0
  4081.      i960:        move    0,d */
  4082.       PERFORM_COPY(v, co, VALUE(0), ci);
  4083.       RECURSE(COPY, CNST(0), 0, prune_hint & ~CY_JUST_SET);
  4084.          
  4085.       /* cy = 100b */
  4086.       PERFORM_CMPO_960(v, co, VALUE(0), VALUE(1), ci);
  4087.       CRECURSE_2OP(CMPO_960, n_values, CNST(0), CNST(1), 1, CY_JUST_SET | CY_0);
  4088.     }
  4089.  
  4090. #ifdef TIMING
  4091.   timings[allowed_cost] += cputime() - time_start;
  4092. #endif
  4093. }
  4094. #endif
  4095.